Regenerate documentation.
diff --git a/asio/src/doc/reference.qbk b/asio/src/doc/reference.qbk index 7a9e7e7..52f6b41 100644 --- a/asio/src/doc/reference.qbk +++ b/asio/src/doc/reference.qbk
@@ -24,6 +24,7 @@ [include requirements/ConvertibleToMutableBuffer.qbk] [include requirements/DatagramSocketService.qbk] [include requirements/DescriptorService.qbk] +[include requirements/DynamicBufferSequence.qbk] [include requirements/Endpoint.qbk] [include requirements/Executor.qbk] [include requirements/GettableSerialPortOption.qbk] @@ -698,7 +699,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_connect.overload1 async_connect]``( basic_socket< Protocol, SocketService > & s, Iterator begin, - ComposedConnectHandler handler); + ComposedConnectHandler && handler); `` [''''»''' [link asio.reference.async_connect.overload1 more...]]`` template< @@ -710,7 +711,7 @@ basic_socket< Protocol, SocketService > & s, Iterator begin, Iterator end, - ComposedConnectHandler handler); + ComposedConnectHandler && handler); `` [''''»''' [link asio.reference.async_connect.overload2 more...]]`` template< @@ -723,7 +724,7 @@ basic_socket< Protocol, SocketService > & s, Iterator begin, ConnectCondition connect_condition, - ComposedConnectHandler handler); + ComposedConnectHandler && handler); `` [''''»''' [link asio.reference.async_connect.overload3 more...]]`` template< @@ -737,7 +738,7 @@ Iterator begin, Iterator end, ConnectCondition connect_condition, - ComposedConnectHandler handler); + ComposedConnectHandler && handler); `` [''''»''' [link asio.reference.async_connect.overload4 more...]]`` [heading Requirements] @@ -761,7 +762,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_connect( basic_socket< Protocol, SocketService > & s, Iterator begin, - ComposedConnectHandler handler); + ComposedConnectHandler && handler); This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `async_connect` member function, once for each endpoint in the sequence, until a connection is successfully established. @@ -857,7 +858,7 @@ basic_socket< Protocol, SocketService > & s, Iterator begin, Iterator end, - ComposedConnectHandler handler); + ComposedConnectHandler && handler); This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `async_connect` member function, once for each endpoint in the sequence, until a connection is successfully established. @@ -952,7 +953,7 @@ basic_socket< Protocol, SocketService > & s, Iterator begin, ConnectCondition connect_condition, - ComposedConnectHandler handler); + ComposedConnectHandler && handler); This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `async_connect` member function, once for each endpoint in the sequence, until a connection is successfully established. @@ -1083,7 +1084,7 @@ Iterator begin, Iterator end, ConnectCondition connect_condition, - ComposedConnectHandler handler); + ComposedConnectHandler && handler); This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `async_connect` member function, once for each endpoint in the sequence, until a connection is successfully established. @@ -1209,7 +1210,8 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_read.overload1 async_read]``( AsyncReadStream & s, const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler, + typename enable_if< is_mutable_buffer_sequence< MutableBufferSequence >::value >::type * = 0); `` [''''»''' [link asio.reference.async_read.overload1 more...]]`` template< @@ -1221,30 +1223,55 @@ AsyncReadStream & s, const MutableBufferSequence & buffers, CompletionCondition completion_condition, - ReadHandler handler); + ReadHandler && handler, + typename enable_if< is_mutable_buffer_sequence< MutableBufferSequence >::value >::type * = 0); `` [''''»''' [link asio.reference.async_read.overload2 more...]]`` template< typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename ``[link asio.reference.ReadHandler ReadHandler]``> + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_read.overload3 async_read]``( + AsyncReadStream & s, + DynamicBufferSequence && buffers, + ReadHandler && handler, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); + `` [''''»''' [link asio.reference.async_read.overload3 more...]]`` + + template< + typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename CompletionCondition, + typename ``[link asio.reference.ReadHandler ReadHandler]``> + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_read.overload4 async_read]``( + AsyncReadStream & s, + DynamicBufferSequence && buffers, + CompletionCondition completion_condition, + ReadHandler && handler, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); + `` [''''»''' [link asio.reference.async_read.overload4 more...]]`` + + template< + typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``, typename Allocator, typename ``[link asio.reference.ReadHandler ReadHandler]``> - ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_read.overload3 async_read]``( + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_read.overload5 async_read]``( AsyncReadStream & s, basic_streambuf< Allocator > & b, - ReadHandler handler); - `` [''''»''' [link asio.reference.async_read.overload3 more...]]`` + ReadHandler && handler); + `` [''''»''' [link asio.reference.async_read.overload5 more...]]`` template< typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``, typename Allocator, typename CompletionCondition, typename ``[link asio.reference.ReadHandler ReadHandler]``> - ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_read.overload4 async_read]``( + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_read.overload6 async_read]``( AsyncReadStream & s, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, - ReadHandler handler); - `` [''''»''' [link asio.reference.async_read.overload4 more...]]`` + ReadHandler && handler); + `` [''''»''' [link asio.reference.async_read.overload6 more...]]`` [heading Requirements] @@ -1253,7 +1280,7 @@ ['Convenience header: ][^asio.hpp] -[section:overload1 async_read (1 of 4 overloads)] +[section:overload1 async_read (1 of 6 overloads)] Start an asynchronous operation to read a certain amount of data from a stream. @@ -1266,7 +1293,8 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_read( AsyncReadStream & s, const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler, + typename enable_if< is_mutable_buffer_sequence< MutableBufferSequence >::value >::type * = 0); This function is used to asynchronously read a certain number of bytes of data from a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @@ -1335,7 +1363,7 @@ -[section:overload2 async_read (2 of 4 overloads)] +[section:overload2 async_read (2 of 6 overloads)] Start an asynchronous operation to read a certain amount of data from a stream. @@ -1350,7 +1378,8 @@ AsyncReadStream & s, const MutableBufferSequence & buffers, CompletionCondition completion_condition, - ReadHandler handler); + ReadHandler && handler, + typename enable_if< is_mutable_buffer_sequence< MutableBufferSequence >::value >::type * = 0); This function is used to asynchronously read a certain number of bytes of data from a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @@ -1419,7 +1448,154 @@ -[section:overload3 async_read (3 of 4 overloads)] +[section:overload3 async_read (3 of 6 overloads)] + + +Start an asynchronous operation to read a certain amount of data from a stream. + + + template< + typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename ``[link asio.reference.ReadHandler ReadHandler]``> + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_read( + AsyncReadStream & s, + DynamicBufferSequence && buffers, + ReadHandler && handler, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); + + +This function is used to asynchronously read a certain number of bytes of data from a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: + + +* The specified dynamic buffer sequence is full (that is, it has reached maximum size). + + +* An error occurred. + +This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. The program must ensure that the stream performs no other read operations (such as async\_read, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes. + + +[heading Parameters] + + +[variablelist + +[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]] + +[[buffers][The dynamic buffer sequence into which the data will be read. 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.]] + +[[handler][The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be: +`` + void handler( + const asio::error_code& error, // Result of operation. + + std::size_t bytes_transferred // Number of bytes copied into the + // buffers. If an error occurred, + // this will be the number of + // bytes successfully transferred + // prior to the error. + ); +`` +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_service::post()`.]] + +] + + +[heading Remarks] + +This overload is equivalent to calling: + + asio::async_read( + s, buffers, + asio::transfer_all(), + handler); + + + + + + + +[endsect] + + + +[section:overload4 async_read (4 of 6 overloads)] + + +Start an asynchronous operation to read a certain amount of data from a stream. + + + template< + typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename CompletionCondition, + typename ``[link asio.reference.ReadHandler ReadHandler]``> + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_read( + AsyncReadStream & s, + DynamicBufferSequence && buffers, + CompletionCondition completion_condition, + ReadHandler && handler, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); + + +This function is used to asynchronously read a certain number of bytes of data from a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: + + +* The specified dynamic buffer sequence is full (that is, it has reached maximum size). + + +* The completion\_condition function object returns 0. + +This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. The program must ensure that the stream performs no other read operations (such as async\_read, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes. + + +[heading Parameters] + + +[variablelist + +[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]] + +[[buffers][The dynamic buffer sequence into which the data will be read. 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.]] + +[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: +`` + std::size_t completion_condition( + // Result of latest async_read_some operation. + const asio::error_code& error, + + // Number of bytes transferred so far. + std::size_t bytes_transferred + ); +`` +A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's async\_read\_some function.]] + +[[handler][The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be: +`` + void handler( + const asio::error_code& error, // Result of operation. + + std::size_t bytes_transferred // Number of bytes copied into the + // buffers. If an error occurred, + // this will be the number of + // bytes successfully transferred + // prior to the error. + ); +`` +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_service::post()`. ]] + +] + + + + +[endsect] + + + +[section:overload5 async_read (5 of 6 overloads)] Start an asynchronous operation to read a certain amount of data from a stream. @@ -1432,7 +1608,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_read( AsyncReadStream & s, basic_streambuf< Allocator > & b, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously read a certain number of bytes of data from a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @@ -1491,7 +1667,7 @@ -[section:overload4 async_read (4 of 4 overloads)] +[section:overload6 async_read (6 of 6 overloads)] Start an asynchronous operation to read a certain amount of data from a stream. @@ -1506,7 +1682,7 @@ AsyncReadStream & s, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously read a certain number of bytes of data from a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @@ -1579,7 +1755,7 @@ AsyncRandomAccessReadDevice & d, uint64_t offset, const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); `` [''''»''' [link asio.reference.async_read_at.overload1 more...]]`` template< @@ -1592,7 +1768,7 @@ uint64_t offset, const MutableBufferSequence & buffers, CompletionCondition completion_condition, - ReadHandler handler); + ReadHandler && handler); `` [''''»''' [link asio.reference.async_read_at.overload2 more...]]`` template< @@ -1603,7 +1779,7 @@ AsyncRandomAccessReadDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, - ReadHandler handler); + ReadHandler && handler); `` [''''»''' [link asio.reference.async_read_at.overload3 more...]]`` template< @@ -1616,7 +1792,7 @@ uint64_t offset, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, - ReadHandler handler); + ReadHandler && handler); `` [''''»''' [link asio.reference.async_read_at.overload4 more...]]`` [heading Requirements] @@ -1640,7 +1816,7 @@ AsyncRandomAccessReadDevice & d, uint64_t offset, const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously read a certain number of bytes of data from a random access device at the specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @@ -1727,7 +1903,7 @@ uint64_t offset, const MutableBufferSequence & buffers, CompletionCondition completion_condition, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously read a certain number of bytes of data from a random access device at the specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @@ -1812,7 +1988,7 @@ AsyncRandomAccessReadDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously read a certain number of bytes of data from a random access device at the specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @@ -1886,7 +2062,7 @@ uint64_t offset, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously read a certain number of bytes of data from a random access device at the specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @@ -1947,54 +2123,100 @@ [section:async_read_until async_read_until] [indexterm1 async_read_until] -Start an asynchronous operation to read data into a streambuf until it contains a delimiter, matches a regular expression, or a function object indicates a match. +Start an asynchronous operation to read data into a dynamic buffer sequence, or into a streambuf, until it contains a delimiter, matches a regular expression, or a function object indicates a match. template< typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``, - typename Allocator, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, typename ``[link asio.reference.ReadHandler ReadHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_read_until.overload1 async_read_until]``( AsyncReadStream & s, - asio::basic_streambuf< Allocator > & b, + DynamicBufferSequence && buffers, char delim, - ReadHandler handler); + ReadHandler && handler); `` [''''»''' [link asio.reference.async_read_until.overload1 more...]]`` template< typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``, - typename Allocator, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, typename ``[link asio.reference.ReadHandler ReadHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_read_until.overload2 async_read_until]``( AsyncReadStream & s, - asio::basic_streambuf< Allocator > & b, + DynamicBufferSequence && buffers, const std::string & delim, - ReadHandler handler); + ReadHandler && handler); `` [''''»''' [link asio.reference.async_read_until.overload2 more...]]`` template< typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename ``[link asio.reference.ReadHandler ReadHandler]``> + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_read_until.overload3 async_read_until]``( + AsyncReadStream & s, + DynamicBufferSequence && buffers, + const boost::regex & expr, + ReadHandler && handler); + `` [''''»''' [link asio.reference.async_read_until.overload3 more...]]`` + + template< + typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename MatchCondition, + typename ``[link asio.reference.ReadHandler ReadHandler]``> + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_read_until.overload4 async_read_until]``( + AsyncReadStream & s, + DynamicBufferSequence && buffers, + MatchCondition match_condition, + ReadHandler && handler, + typename enable_if< is_match_condition< MatchCondition >::value >::type * = 0); + `` [''''»''' [link asio.reference.async_read_until.overload4 more...]]`` + + template< + typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``, typename Allocator, typename ``[link asio.reference.ReadHandler ReadHandler]``> - ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_read_until.overload3 async_read_until]``( + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_read_until.overload5 async_read_until]``( + AsyncReadStream & s, + asio::basic_streambuf< Allocator > & b, + char delim, + ReadHandler && handler); + `` [''''»''' [link asio.reference.async_read_until.overload5 more...]]`` + + template< + typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``, + typename Allocator, + typename ``[link asio.reference.ReadHandler ReadHandler]``> + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_read_until.overload6 async_read_until]``( + AsyncReadStream & s, + asio::basic_streambuf< Allocator > & b, + const std::string & delim, + ReadHandler && handler); + `` [''''»''' [link asio.reference.async_read_until.overload6 more...]]`` + + template< + typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``, + typename Allocator, + typename ``[link asio.reference.ReadHandler ReadHandler]``> + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_read_until.overload7 async_read_until]``( AsyncReadStream & s, asio::basic_streambuf< Allocator > & b, const boost::regex & expr, - ReadHandler handler); - `` [''''»''' [link asio.reference.async_read_until.overload3 more...]]`` + ReadHandler && handler); + `` [''''»''' [link asio.reference.async_read_until.overload7 more...]]`` template< typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``, typename Allocator, typename MatchCondition, typename ``[link asio.reference.ReadHandler ReadHandler]``> - ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_read_until.overload4 async_read_until]``( + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_read_until.overload8 async_read_until]``( AsyncReadStream & s, asio::basic_streambuf< Allocator > & b, MatchCondition match_condition, - ReadHandler handler, + ReadHandler && handler, typename enable_if< is_match_condition< MatchCondition >::value >::type * = 0); - `` [''''»''' [link asio.reference.async_read_until.overload4 more...]]`` + `` [''''»''' [link asio.reference.async_read_until.overload8 more...]]`` [heading Requirements] @@ -2003,7 +2225,459 @@ ['Convenience header: ][^asio.hpp] -[section:overload1 async_read_until (1 of 4 overloads)] +[section:overload1 async_read_until (1 of 8 overloads)] + + +Start an asynchronous operation to read data into a dynamic buffer sequence until it contains a specified delimiter. + + + template< + typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename ``[link asio.reference.ReadHandler ReadHandler]``> + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_read_until( + AsyncReadStream & s, + DynamicBufferSequence && buffers, + char delim, + ReadHandler && handler); + + +This function is used to asynchronously read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains the specified delimiter. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: + + +* The get area of the dynamic buffer sequence contains the specified delimiter. + + +* An error occurred. + +This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. If the dynamic buffer sequence's get area already contains the delimiter, this asynchronous operation completes immediately. The program must ensure that the stream performs no other read operations (such as async\_read, async\_read\_until, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes. + + +[heading Parameters] + + +[variablelist + +[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]] + +[[buffers][The dynamic buffer sequence into which the data will be read. 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.]] + +[[delim][The delimiter character.]] + +[[handler][The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be: +`` + void handler( + // Result of operation. + const asio::error_code& error, + + // The number of bytes in the dynamic buffer sequence's + // get area up to and including the delimiter. + // 0 if an error occurred. + std::size_t bytes_transferred + ); +`` +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_service::post()`.]] + +] + + +[heading Remarks] + +After a successful async\_read\_until operation, the dynamic buffer sequence may contain additional data beyond the delimiter. An application will typically leave that data in the dynamic buffer sequence for a subsequent async\_read\_until operation to examine. + + +[heading Example] + +To asynchronously read data into a `std::string` until a newline is encountered: + + std::string data; + ... + void handler(const asio::error_code& e, std::size_t size) + { + if (!e) + { + std::string line = data.substr(0, n); + data.erase(0, n); + ... + } + } + ... + asio::async_read_until(s, data, '\n', handler); + + +After the `async_read_until` operation completes successfully, the buffer `data` contains the delimiter: + + { 'a', 'b', ..., 'c', '\n', 'd', 'e', ... } + + +The call to `substr` then extracts the data up to and including the delimiter, so that the string `line` contains: + + { 'a', 'b', ..., 'c', '\n' } + + +After the call to `erase`, the remaining data is left in the buffer `data` as follows: + + { 'd', 'e', ... } + + +This data may be the start of a new line, to be extracted by a subsequent `async_read_until` operation. + + + + +[endsect] + + + +[section:overload2 async_read_until (2 of 8 overloads)] + + +Start an asynchronous operation to read data into a dynamic buffer sequence until it contains a specified delimiter. + + + template< + typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename ``[link asio.reference.ReadHandler ReadHandler]``> + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_read_until( + AsyncReadStream & s, + DynamicBufferSequence && buffers, + const std::string & delim, + ReadHandler && handler); + + +This function is used to asynchronously read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains the specified delimiter. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: + + +* The get area of the dynamic buffer sequence contains the specified delimiter. + + +* An error occurred. + +This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. If the dynamic buffer sequence's get area already contains the delimiter, this asynchronous operation completes immediately. The program must ensure that the stream performs no other read operations (such as async\_read, async\_read\_until, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes. + + +[heading Parameters] + + +[variablelist + +[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]] + +[[buffers][The dynamic buffer sequence into which the data will be read. 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.]] + +[[delim][The delimiter string.]] + +[[handler][The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be: +`` + void handler( + // Result of operation. + const asio::error_code& error, + + // The number of bytes in the dynamic buffer sequence's + // get area up to and including the delimiter. + // 0 if an error occurred. + std::size_t bytes_transferred + ); +`` +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_service::post()`.]] + +] + + +[heading Remarks] + +After a successful async\_read\_until operation, the dynamic buffer sequence may contain additional data beyond the delimiter. An application will typically leave that data in the dynamic buffer sequence for a subsequent async\_read\_until operation to examine. + + +[heading Example] + +To asynchronously read data into a `std::string` until a CR-LF sequence is encountered: + + std::string data; + ... + void handler(const asio::error_code& e, std::size_t size) + { + if (!e) + { + std::string line = data.substr(0, n); + data.erase(0, n); + ... + } + } + ... + asio::async_read_until(s, data, "\r\n", handler); + + +After the `async_read_until` operation completes successfully, the string `data` contains the delimiter: + + { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } + + +The call to `substr` then extracts the data up to and including the delimiter, so that the string `line` contains: + + { 'a', 'b', ..., 'c', '\r', '\n' } + + +After the call to `erase`, the remaining data is left in the string `data` as follows: + + { 'd', 'e', ... } + + +This data may be the start of a new line, to be extracted by a subsequent `async_read_until` operation. + + + + +[endsect] + + + +[section:overload3 async_read_until (3 of 8 overloads)] + + +Start an asynchronous operation to read data into a dynamic buffer sequence until some part of its data matches a regular expression. + + + template< + typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename ``[link asio.reference.ReadHandler ReadHandler]``> + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_read_until( + AsyncReadStream & s, + DynamicBufferSequence && buffers, + const boost::regex & expr, + ReadHandler && handler); + + +This function is used to asynchronously read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains some data that matches a regular expression. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: + + +* A substring of the dynamic buffer sequence's get area matches the regular expression. + + +* An error occurred. + +This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. If the dynamic buffer sequence's get area already contains data that matches the regular expression, this asynchronous operation completes immediately. The program must ensure that the stream performs no other read operations (such as async\_read, async\_read\_until, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes. + + +[heading Parameters] + + +[variablelist + +[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]] + +[[buffers][The dynamic buffer sequence into which the data will be read. 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.]] + +[[expr][The regular expression.]] + +[[handler][The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be: +`` + void handler( + // Result of operation. + const asio::error_code& error, + + // The number of bytes in the dynamic buffer + // sequence's get area up to and including the + // substring that matches the regular expression. + // 0 if an error occurred. + std::size_t bytes_transferred + ); +`` +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_service::post()`.]] + +] + + +[heading Remarks] + +After a successful async\_read\_until operation, the dynamic buffer sequence may contain additional data beyond that which matched the regular expression. An application will typically leave that data in the dynamic buffer sequence for a subsequent async\_read\_until operation to examine. + + +[heading Example] + +To asynchronously read data into a `std::string` until a CR-LF sequence is encountered: + + std::string data; + ... + void handler(const asio::error_code& e, std::size_t size) + { + if (!e) + { + std::string line = data.substr(0, n); + data.erase(0, n); + ... + } + } + ... + asio::async_read_until(s, data, + boost::regex("\r\n"), handler); + + +After the `async_read_until` operation completes successfully, the string `data` contains the data which matched the regular expression: + + { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } + + +The call to `substr` then extracts the data up to and including the match, so that the string `line` contains: + + { 'a', 'b', ..., 'c', '\r', '\n' } + + +After the call to `erase`, the remaining data is left in the string `data` as follows: + + { 'd', 'e', ... } + + +This data may be the start of a new line, to be extracted by a subsequent `async_read_until` operation. + + + + +[endsect] + + + +[section:overload4 async_read_until (4 of 8 overloads)] + + +Start an asynchronous operation to read data into a dynamic buffer sequence until a function object indicates a match. + + + template< + typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename MatchCondition, + typename ``[link asio.reference.ReadHandler ReadHandler]``> + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_read_until( + AsyncReadStream & s, + DynamicBufferSequence && buffers, + MatchCondition match_condition, + ReadHandler && handler, + typename enable_if< is_match_condition< MatchCondition >::value >::type * = 0); + + +This function is used to asynchronously read data into the specified dynamic buffer sequence until a user-defined match condition function object, when applied to the data contained in the dynamic buffer sequence, indicates a successful match. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: + + +* The match condition function object returns a std::pair where the second element evaluates to true. + + +* An error occurred. + +This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. If the match condition function object already indicates a match, this asynchronous operation completes immediately. The program must ensure that the stream performs no other read operations (such as async\_read, async\_read\_until, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes. + + +[heading Parameters] + + +[variablelist + +[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]] + +[[buffers][The dynamic buffer sequence into which the data will be read. 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.]] + +[[match_condition][The function object to be called to determine whether a match exists. The signature of the function object must be: +`` + pair<iterator, bool> match_condition(iterator begin, iterator end); +`` +where `iterator` represents the type: +`` + buffers_iterator<typename DynamicBufferSequence::const_buffers_type> +`` +The iterator parameters `begin` and `end` define the range of bytes to be scanned to determine whether there is a match. The `first` member of the return value is an iterator marking one-past-the-end of the bytes that have been consumed by the match function. This iterator is used to calculate the `begin` parameter for any subsequent invocation of the match condition. The `second` member of the return value is true if a match has been found, false otherwise.]] + +[[handler][The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be: +`` + void handler( + // Result of operation. + const asio::error_code& error, + + // The number of bytes in the dynamic buffer sequence's + // get area that have been fully consumed by the match + // function. O if an error occurred. + std::size_t bytes_transferred + ); +`` +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_service::post()`.]] + +] + + +[heading Remarks] + +After a successful async\_read\_until operation, the dynamic buffer sequence may contain additional data beyond that which matched the function object. An application will typically leave that data in the dynamic buffer sequence for a subsequent async\_read\_until operation to examine. + +The default implementation of the `is_match_condition` type trait evaluates to true for function pointers and function objects with a `result_type` typedef. It must be specialised for other user-defined function objects. + + +[heading Examples] + +To asynchronously read data into a `std::string` until whitespace is encountered: + + typedef asio::buffers_iterator< + asio::const_buffers_1> iterator; + + std::pair<iterator, bool> + match_whitespace(iterator begin, iterator end) + { + iterator i = begin; + while (i != end) + if (std::isspace(*i++)) + return std::make_pair(i, true); + return std::make_pair(i, false); + } + ... + void handler(const asio::error_code& e, std::size_t size); + ... + std::string data; + asio::async_read_until(s, data, match_whitespace, handler); + + + + +To asynchronously read data into a `std::string` until a matching character is found: + + class match_char + { + public: + explicit match_char(char c) : c_(c) {} + + template <typename Iterator> + std::pair<Iterator, bool> operator()( + Iterator begin, Iterator end) const + { + Iterator i = begin; + while (i != end) + if (c_ == *i++) + return std::make_pair(i, true); + return std::make_pair(i, false); + } + + private: + char c_; + }; + + namespace asio { + template <> struct is_match_condition<match_char> + : public boost::true_type {}; + } // namespace asio + ... + void handler(const asio::error_code& e, std::size_t size); + ... + std::string data; + asio::async_read_until(s, data, match_char('a'), handler); + + + + + +[endsect] + + + +[section:overload5 async_read_until (5 of 8 overloads)] Start an asynchronous operation to read data into a streambuf until it contains a specified delimiter. @@ -2017,7 +2691,7 @@ AsyncReadStream & s, asio::basic_streambuf< Allocator > & b, char delim, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously read data into the specified streambuf until the streambuf's get area contains the specified delimiter. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @@ -2108,7 +2782,7 @@ -[section:overload2 async_read_until (2 of 4 overloads)] +[section:overload6 async_read_until (6 of 8 overloads)] Start an asynchronous operation to read data into a streambuf until it contains a specified delimiter. @@ -2122,7 +2796,7 @@ AsyncReadStream & s, asio::basic_streambuf< Allocator > & b, const std::string & delim, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously read data into the specified streambuf until the streambuf's get area contains the specified delimiter. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @@ -2213,7 +2887,7 @@ -[section:overload3 async_read_until (3 of 4 overloads)] +[section:overload7 async_read_until (7 of 8 overloads)] Start an asynchronous operation to read data into a streambuf until some part of its data matches a regular expression. @@ -2227,7 +2901,7 @@ AsyncReadStream & s, asio::basic_streambuf< Allocator > & b, const boost::regex & expr, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously read data into the specified streambuf until the streambuf's get area contains some data that matches a regular expression. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @@ -2319,7 +2993,7 @@ -[section:overload4 async_read_until (4 of 4 overloads)] +[section:overload8 async_read_until (8 of 8 overloads)] Start an asynchronous operation to read data into a streambuf until a function object indicates a match. @@ -2334,7 +3008,7 @@ AsyncReadStream & s, asio::basic_streambuf< Allocator > & b, MatchCondition match_condition, - ReadHandler handler, + ReadHandler && handler, typename enable_if< is_match_condition< MatchCondition >::value >::type * = 0); @@ -2574,7 +3248,8 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_write.overload1 async_write]``( AsyncWriteStream & s, const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler, + typename enable_if< is_const_buffer_sequence< ConstBufferSequence >::value >::type * = 0); `` [''''»''' [link asio.reference.async_write.overload1 more...]]`` template< @@ -2586,30 +3261,55 @@ AsyncWriteStream & s, const ConstBufferSequence & buffers, CompletionCondition completion_condition, - WriteHandler handler); + WriteHandler && handler, + typename enable_if< is_const_buffer_sequence< ConstBufferSequence >::value >::type * = 0); `` [''''»''' [link asio.reference.async_write.overload2 more...]]`` template< typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename ``[link asio.reference.WriteHandler WriteHandler]``> + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_write.overload3 async_write]``( + AsyncWriteStream & s, + DynamicBufferSequence && buffers, + WriteHandler && handler, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); + `` [''''»''' [link asio.reference.async_write.overload3 more...]]`` + + template< + typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename CompletionCondition, + typename ``[link asio.reference.WriteHandler WriteHandler]``> + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_write.overload4 async_write]``( + AsyncWriteStream & s, + DynamicBufferSequence && buffers, + CompletionCondition completion_condition, + WriteHandler && handler, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); + `` [''''»''' [link asio.reference.async_write.overload4 more...]]`` + + template< + typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``, typename Allocator, typename ``[link asio.reference.WriteHandler WriteHandler]``> - ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_write.overload3 async_write]``( + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_write.overload5 async_write]``( AsyncWriteStream & s, basic_streambuf< Allocator > & b, - WriteHandler handler); - `` [''''»''' [link asio.reference.async_write.overload3 more...]]`` + WriteHandler && handler); + `` [''''»''' [link asio.reference.async_write.overload5 more...]]`` template< typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``, typename Allocator, typename CompletionCondition, typename ``[link asio.reference.WriteHandler WriteHandler]``> - ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_write.overload4 async_write]``( + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.async_write.overload6 async_write]``( AsyncWriteStream & s, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, - WriteHandler handler); - `` [''''»''' [link asio.reference.async_write.overload4 more...]]`` + WriteHandler && handler); + `` [''''»''' [link asio.reference.async_write.overload6 more...]]`` [heading Requirements] @@ -2618,7 +3318,7 @@ ['Convenience header: ][^asio.hpp] -[section:overload1 async_write (1 of 4 overloads)] +[section:overload1 async_write (1 of 6 overloads)] Start an asynchronous operation to write all of the supplied data to a stream. @@ -2631,7 +3331,8 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_write( AsyncWriteStream & s, const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler, + typename enable_if< is_const_buffer_sequence< ConstBufferSequence >::value >::type * = 0); 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: @@ -2686,7 +3387,7 @@ -[section:overload2 async_write (2 of 4 overloads)] +[section:overload2 async_write (2 of 6 overloads)] Start an asynchronous operation to write a certain amount of data to a stream. @@ -2701,7 +3402,8 @@ AsyncWriteStream & s, const ConstBufferSequence & buffers, CompletionCondition completion_condition, - WriteHandler handler); + WriteHandler && handler, + typename enable_if< is_const_buffer_sequence< ConstBufferSequence >::value >::type * = 0); 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: @@ -2771,7 +3473,139 @@ -[section:overload3 async_write (3 of 4 overloads)] +[section:overload3 async_write (3 of 6 overloads)] + + +Start an asynchronous operation to write all of the supplied data to a stream. + + + template< + typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename ``[link asio.reference.WriteHandler WriteHandler]``> + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_write( + AsyncWriteStream & s, + DynamicBufferSequence && buffers, + WriteHandler && handler, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); + + +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: + + +* All of the data in the supplied dynamic buffer sequence has been written. + + +* 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 ['composed operation]. 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. + + +[heading Parameters] + + +[variablelist + +[[s][The stream to which the data is to be written. The type must support the AsyncWriteStream concept.]] + +[[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.]] + +[[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: +`` + 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. + ); +`` +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_service::post()`. ]] + +] + + + + +[endsect] + + + +[section:overload4 async_write (4 of 6 overloads)] + + +Start an asynchronous operation to write a certain amount of data to a stream. + + + template< + typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename CompletionCondition, + typename ``[link asio.reference.WriteHandler WriteHandler]``> + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_write( + AsyncWriteStream & s, + DynamicBufferSequence && buffers, + CompletionCondition completion_condition, + WriteHandler && handler, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); + + +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: + + +* All of the data in the supplied dynamic buffer sequence has been written. + + +* 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 ['composed operation]. 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. + + +[heading Parameters] + + +[variablelist + +[[s][The stream to which the data is to be written. The type must support the AsyncWriteStream concept.]] + +[[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.]] + +[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: +`` + 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 + ); +`` +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.]] + +[[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: +`` + 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. + ); +`` +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_service::post()`. ]] + +] + + + + +[endsect] + + + +[section:overload5 async_write (5 of 6 overloads)] Start an asynchronous operation to write all of the supplied data to a stream. @@ -2784,7 +3618,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_write( AsyncWriteStream & s, basic_streambuf< Allocator > & b, - WriteHandler handler); + WriteHandler && handler); 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: @@ -2829,7 +3663,7 @@ -[section:overload4 async_write (4 of 4 overloads)] +[section:overload6 async_write (6 of 6 overloads)] Start an asynchronous operation to write a certain amount of data to a stream. @@ -2844,7 +3678,7 @@ AsyncWriteStream & s, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, - WriteHandler handler); + WriteHandler && handler); 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: @@ -2916,7 +3750,7 @@ AsyncRandomAccessWriteDevice & d, uint64_t offset, const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); `` [''''»''' [link asio.reference.async_write_at.overload1 more...]]`` template< @@ -2929,7 +3763,7 @@ uint64_t offset, const ConstBufferSequence & buffers, CompletionCondition completion_condition, - WriteHandler handler); + WriteHandler && handler); `` [''''»''' [link asio.reference.async_write_at.overload2 more...]]`` template< @@ -2940,7 +3774,7 @@ AsyncRandomAccessWriteDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, - WriteHandler handler); + WriteHandler && handler); `` [''''»''' [link asio.reference.async_write_at.overload3 more...]]`` template< @@ -2953,7 +3787,7 @@ uint64_t offset, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, - WriteHandler handler); + WriteHandler && handler); `` [''''»''' [link asio.reference.async_write_at.overload4 more...]]`` [heading Requirements] @@ -2977,7 +3811,7 @@ AsyncRandomAccessWriteDevice & d, uint64_t offset, const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); This function is used to asynchronously write a certain number of bytes of data to a random access device at a specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @@ -3050,7 +3884,7 @@ uint64_t offset, const ConstBufferSequence & buffers, CompletionCondition completion_condition, - WriteHandler handler); + WriteHandler && handler); This function is used to asynchronously write a certain number of bytes of data to a random access device at a specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @@ -3136,7 +3970,7 @@ AsyncRandomAccessWriteDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, - WriteHandler handler); + WriteHandler && handler); This function is used to asynchronously write a certain number of bytes of data to a random access device at a specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @@ -3199,7 +4033,7 @@ uint64_t offset, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, - WriteHandler handler); + WriteHandler && handler); This function is used to asynchronously write a certain number of bytes of data to a random access device at a specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @@ -3825,7 +4659,7 @@ typename ``[link asio.reference.ConnectHandler ConnectHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_connect( const endpoint_type & peer_endpoint, - ConnectHandler handler); + ConnectHandler && handler); This function is used to asynchronously connect a socket to the specified remote endpoint. The function call always returns immediately. @@ -3890,7 +4724,7 @@ typename ``[link asio.reference.ReadHandler ReadHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.basic_datagram_socket.async_receive.overload1 async_receive]``( const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); `` [''''»''' [link asio.reference.basic_datagram_socket.async_receive.overload1 more...]]`` template< @@ -3899,7 +4733,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.basic_datagram_socket.async_receive.overload2 async_receive]``( const MutableBufferSequence & buffers, socket_base::message_flags flags, - ReadHandler handler); + ReadHandler && handler); `` [''''»''' [link asio.reference.basic_datagram_socket.async_receive.overload2 more...]]`` @@ -3914,7 +4748,7 @@ typename ``[link asio.reference.ReadHandler ReadHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_receive( const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously receive data from the datagram socket. The function call always returns immediately. @@ -3972,7 +4806,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_receive( const MutableBufferSequence & buffers, socket_base::message_flags flags, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously receive data from the datagram socket. The function call always returns immediately. @@ -4023,7 +4857,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.basic_datagram_socket.async_receive_from.overload1 async_receive_from]``( const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, - ReadHandler handler); + ReadHandler && handler); `` [''''»''' [link asio.reference.basic_datagram_socket.async_receive_from.overload1 more...]]`` template< @@ -4033,7 +4867,7 @@ const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, socket_base::message_flags flags, - ReadHandler handler); + ReadHandler && handler); `` [''''»''' [link asio.reference.basic_datagram_socket.async_receive_from.overload2 more...]]`` @@ -4049,7 +4883,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_receive_from( const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously receive a datagram. The function call always returns immediately. @@ -4106,7 +4940,7 @@ const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, socket_base::message_flags flags, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously receive a datagram. The function call always returns immediately. @@ -4153,7 +4987,7 @@ typename ``[link asio.reference.WriteHandler WriteHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.basic_datagram_socket.async_send.overload1 async_send]``( const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); `` [''''»''' [link asio.reference.basic_datagram_socket.async_send.overload1 more...]]`` template< @@ -4162,7 +4996,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.basic_datagram_socket.async_send.overload2 async_send]``( const ConstBufferSequence & buffers, socket_base::message_flags flags, - WriteHandler handler); + WriteHandler && handler); `` [''''»''' [link asio.reference.basic_datagram_socket.async_send.overload2 more...]]`` @@ -4177,7 +5011,7 @@ typename ``[link asio.reference.WriteHandler WriteHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_send( const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); This function is used to asynchronously send data on the datagram socket. The function call always returns immediately. @@ -4235,7 +5069,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_send( const ConstBufferSequence & buffers, socket_base::message_flags flags, - WriteHandler handler); + WriteHandler && handler); This function is used to asynchronously send data on the datagram socket. The function call always returns immediately. @@ -4286,7 +5120,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.basic_datagram_socket.async_send_to.overload1 async_send_to]``( const ConstBufferSequence & buffers, const endpoint_type & destination, - WriteHandler handler); + WriteHandler && handler); `` [''''»''' [link asio.reference.basic_datagram_socket.async_send_to.overload1 more...]]`` template< @@ -4296,7 +5130,7 @@ const ConstBufferSequence & buffers, const endpoint_type & destination, socket_base::message_flags flags, - WriteHandler handler); + WriteHandler && handler); `` [''''»''' [link asio.reference.basic_datagram_socket.async_send_to.overload2 more...]]`` @@ -4312,7 +5146,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_send_to( const ConstBufferSequence & buffers, const endpoint_type & destination, - WriteHandler handler); + WriteHandler && handler); This function is used to asynchronously send a datagram to the specified remote endpoint. The function call always returns immediately. @@ -4371,7 +5205,7 @@ const ConstBufferSequence & buffers, const endpoint_type & destination, socket_base::message_flags flags, - WriteHandler handler); + WriteHandler && handler); This function is used to asynchronously send a datagram to the specified remote endpoint. The function call always returns immediately. @@ -4421,7 +5255,7 @@ typename ``[link asio.reference.WaitHandler WaitHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( wait_type w, - WaitHandler handler); + WaitHandler && handler); This function is used to perform an asynchronous wait for a socket to enter a ready to read, write or error condition state. @@ -9659,7 +10493,7 @@ template< typename ``[link asio.reference.WaitHandler WaitHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( - WaitHandler handler); + WaitHandler && handler); This function may be used to initiate an asynchronous wait against the timer. It always returns immediately. @@ -11695,7 +12529,7 @@ typename ``[link asio.reference.ConnectHandler ConnectHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_connect( const endpoint_type & peer_endpoint, - ConnectHandler handler); + ConnectHandler && handler); This function is used to asynchronously connect a socket to the specified remote endpoint. The function call always returns immediately. @@ -11760,7 +12594,7 @@ typename ``[link asio.reference.ReadHandler ReadHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.basic_raw_socket.async_receive.overload1 async_receive]``( const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); `` [''''»''' [link asio.reference.basic_raw_socket.async_receive.overload1 more...]]`` template< @@ -11769,7 +12603,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.basic_raw_socket.async_receive.overload2 async_receive]``( const MutableBufferSequence & buffers, socket_base::message_flags flags, - ReadHandler handler); + ReadHandler && handler); `` [''''»''' [link asio.reference.basic_raw_socket.async_receive.overload2 more...]]`` @@ -11784,7 +12618,7 @@ typename ``[link asio.reference.ReadHandler ReadHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_receive( const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously receive data from the raw socket. The function call always returns immediately. @@ -11842,7 +12676,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_receive( const MutableBufferSequence & buffers, socket_base::message_flags flags, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously receive data from the raw socket. The function call always returns immediately. @@ -11893,7 +12727,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.basic_raw_socket.async_receive_from.overload1 async_receive_from]``( const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, - ReadHandler handler); + ReadHandler && handler); `` [''''»''' [link asio.reference.basic_raw_socket.async_receive_from.overload1 more...]]`` template< @@ -11903,7 +12737,7 @@ const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, socket_base::message_flags flags, - ReadHandler handler); + ReadHandler && handler); `` [''''»''' [link asio.reference.basic_raw_socket.async_receive_from.overload2 more...]]`` @@ -11919,7 +12753,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_receive_from( const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously receive raw data. The function call always returns immediately. @@ -11976,7 +12810,7 @@ const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, socket_base::message_flags flags, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously receive raw data. The function call always returns immediately. @@ -12023,7 +12857,7 @@ typename ``[link asio.reference.WriteHandler WriteHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.basic_raw_socket.async_send.overload1 async_send]``( const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); `` [''''»''' [link asio.reference.basic_raw_socket.async_send.overload1 more...]]`` template< @@ -12032,7 +12866,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.basic_raw_socket.async_send.overload2 async_send]``( const ConstBufferSequence & buffers, socket_base::message_flags flags, - WriteHandler handler); + WriteHandler && handler); `` [''''»''' [link asio.reference.basic_raw_socket.async_send.overload2 more...]]`` @@ -12047,7 +12881,7 @@ typename ``[link asio.reference.WriteHandler WriteHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_send( const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); This function is used to send data on the raw socket. The function call will block until the data has been sent successfully or an error occurs. @@ -12105,7 +12939,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_send( const ConstBufferSequence & buffers, socket_base::message_flags flags, - WriteHandler handler); + WriteHandler && handler); This function is used to send data on the raw socket. The function call will block until the data has been sent successfully or an error occurs. @@ -12156,7 +12990,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.basic_raw_socket.async_send_to.overload1 async_send_to]``( const ConstBufferSequence & buffers, const endpoint_type & destination, - WriteHandler handler); + WriteHandler && handler); `` [''''»''' [link asio.reference.basic_raw_socket.async_send_to.overload1 more...]]`` template< @@ -12166,7 +13000,7 @@ const ConstBufferSequence & buffers, const endpoint_type & destination, socket_base::message_flags flags, - WriteHandler handler); + WriteHandler && handler); `` [''''»''' [link asio.reference.basic_raw_socket.async_send_to.overload2 more...]]`` @@ -12182,7 +13016,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_send_to( const ConstBufferSequence & buffers, const endpoint_type & destination, - WriteHandler handler); + WriteHandler && handler); This function is used to asynchronously send raw data to the specified remote endpoint. The function call always returns immediately. @@ -12241,7 +13075,7 @@ const ConstBufferSequence & buffers, const endpoint_type & destination, socket_base::message_flags flags, - WriteHandler handler); + WriteHandler && handler); This function is used to asynchronously send raw data to the specified remote endpoint. The function call always returns immediately. @@ -12291,7 +13125,7 @@ typename ``[link asio.reference.WaitHandler WaitHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( wait_type w, - WaitHandler handler); + WaitHandler && handler); This function is used to perform an asynchronous wait for a socket to enter a ready to read, write or error condition state. @@ -17767,7 +18601,7 @@ typename ``[link asio.reference.ConnectHandler ConnectHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_connect( const endpoint_type & peer_endpoint, - ConnectHandler handler); + ConnectHandler && handler); This function is used to asynchronously connect a socket to the specified remote endpoint. The function call always returns immediately. @@ -17833,7 +18667,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.basic_seq_packet_socket.async_receive.overload1 async_receive]``( const MutableBufferSequence & buffers, socket_base::message_flags & out_flags, - ReadHandler handler); + ReadHandler && handler); `` [''''»''' [link asio.reference.basic_seq_packet_socket.async_receive.overload1 more...]]`` template< @@ -17843,7 +18677,7 @@ const MutableBufferSequence & buffers, socket_base::message_flags in_flags, socket_base::message_flags & out_flags, - ReadHandler handler); + ReadHandler && handler); `` [''''»''' [link asio.reference.basic_seq_packet_socket.async_receive.overload2 more...]]`` @@ -17859,7 +18693,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_receive( const MutableBufferSequence & buffers, socket_base::message_flags & out_flags, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously receive data from the sequenced packet socket. The function call always returns immediately. @@ -17915,7 +18749,7 @@ const MutableBufferSequence & buffers, socket_base::message_flags in_flags, socket_base::message_flags & out_flags, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously receive data from the sequenced data socket. The function call always returns immediately. @@ -17976,7 +18810,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_send( const ConstBufferSequence & buffers, socket_base::message_flags flags, - WriteHandler handler); + WriteHandler && handler); This function is used to asynchronously send data on the sequenced packet socket. The function call always returns immediately. @@ -18032,7 +18866,7 @@ typename ``[link asio.reference.WaitHandler WaitHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( wait_type w, - WaitHandler handler); + WaitHandler && handler); This function is used to perform an asynchronous wait for a socket to enter a ready to read, write or error condition state. @@ -22853,7 +23687,7 @@ typename ``[link asio.reference.ReadHandler ReadHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_read_some( const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously read data from the serial port. The function call always returns immediately. @@ -22910,7 +23744,7 @@ typename ``[link asio.reference.WriteHandler WriteHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_write_some( const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); This function is used to asynchronously write data to the serial port. The function call always returns immediately. @@ -24805,7 +25639,7 @@ template< typename ``[link asio.reference.SignalHandler SignalHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( - SignalHandler handler); + SignalHandler && handler); This function may be used to initiate an asynchronous wait against the signal set. It always returns immediately. @@ -26062,7 +26896,7 @@ typename ``[link asio.reference.ConnectHandler ConnectHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_connect( const endpoint_type & peer_endpoint, - ConnectHandler handler); + ConnectHandler && handler); This function is used to asynchronously connect a socket to the specified remote endpoint. The function call always returns immediately. @@ -26127,7 +26961,7 @@ typename ``[link asio.reference.WaitHandler WaitHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( wait_type w, - WaitHandler handler); + WaitHandler && handler); This function is used to perform an asynchronous wait for a socket to enter a ready to read, write or error condition state. @@ -30454,6 +31288,11 @@ ] [ + [[link asio.reference.basic_socket_acceptor.async_wait [*async_wait]]] + [Asynchronously wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. ] + ] + + [ [[link asio.reference.basic_socket_acceptor.basic_socket_acceptor [*basic_socket_acceptor]]] [Construct an acceptor without opening it. @@ -30554,6 +31393,11 @@ [Set an option on the acceptor. ] ] + [ + [[link asio.reference.basic_socket_acceptor.wait [*wait]]] + [Wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. ] + ] + ] [heading Protected Member Functions] @@ -30967,7 +31811,7 @@ typename ``[link asio.reference.AcceptHandler AcceptHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.basic_socket_acceptor.async_accept.overload1 async_accept]``( basic_socket< Protocol1, SocketService > & peer, - AcceptHandler handler, + AcceptHandler && handler, typename enable_if< is_convertible< Protocol, Protocol1 >::value >::type * = 0); `` [''''»''' [link asio.reference.basic_socket_acceptor.async_accept.overload1 more...]]`` @@ -30977,7 +31821,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.basic_socket_acceptor.async_accept.overload2 async_accept]``( basic_socket< protocol_type, SocketService > & peer, endpoint_type & peer_endpoint, - AcceptHandler handler); + AcceptHandler && handler); `` [''''»''' [link asio.reference.basic_socket_acceptor.async_accept.overload2 more...]]`` @@ -30993,7 +31837,7 @@ typename ``[link asio.reference.AcceptHandler AcceptHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_accept( basic_socket< Protocol1, SocketService > & peer, - AcceptHandler handler, + AcceptHandler && handler, typename enable_if< is_convertible< Protocol, Protocol1 >::value >::type * = 0); @@ -31059,7 +31903,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_accept( basic_socket< protocol_type, SocketService > & peer, endpoint_type & peer_endpoint, - AcceptHandler handler); + AcceptHandler && handler); This function is used to asynchronously accept a new connection into a socket, and additionally obtain the endpoint of the remote peer. The function call always returns immediately. @@ -31092,6 +31936,70 @@ [endsect] + +[section:async_wait basic_socket_acceptor::async_wait] + +[indexterm2 async_wait..basic_socket_acceptor] +Asynchronously wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. + + + template< + typename ``[link asio.reference.WaitHandler WaitHandler]``> + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( + wait_type w, + WaitHandler && handler); + + +This function is used to perform an asynchronous wait for an acceptor to enter a ready to read, write or error condition state. + + +[heading Parameters] + + +[variablelist + +[[w][Specifies the desired acceptor state.]] + +[[handler][The handler to be called when the wait operation completes. Copies will be made of the handler as required. The function signature of the handler must be: +`` + void handler( + const asio::error_code& error // Result of operation + ); +`` +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_service::post()`.]] + +] + + +[heading Example] + + + + void wait_handler(const asio::error_code& error) + { + if (!error) + { + // Wait succeeded. + } + } + + ... + + asio::ip::tcp::acceptor acceptor(io_service); + ... + acceptor.async_wait( + asio::ip::tcp::acceptor::wait_read, + wait_handler); + + + + + + + +[endsect] + + [section:basic_socket_acceptor basic_socket_acceptor::basic_socket_acceptor] [indexterm2 basic_socket_acceptor..basic_socket_acceptor] @@ -33898,6 +34806,109 @@ [endsect] +[section:wait basic_socket_acceptor::wait] + +[indexterm2 wait..basic_socket_acceptor] +Wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. + + + void ``[link asio.reference.basic_socket_acceptor.wait.overload1 wait]``( + wait_type w); + `` [''''»''' [link asio.reference.basic_socket_acceptor.wait.overload1 more...]]`` + + asio::error_code ``[link asio.reference.basic_socket_acceptor.wait.overload2 wait]``( + wait_type w, + asio::error_code & ec); + `` [''''»''' [link asio.reference.basic_socket_acceptor.wait.overload2 more...]]`` + + +[section:overload1 basic_socket_acceptor::wait (1 of 2 overloads)] + + +Wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. + + + void wait( + wait_type w); + + +This function is used to perform a blocking wait for an acceptor to enter a ready to read, write or error condition state. + + +[heading Parameters] + + +[variablelist + +[[w][Specifies the desired acceptor state.]] + +] + + +[heading Example] + +Waiting for an acceptor to become readable. + + asio::ip::tcp::acceptor acceptor(io_service); + ... + acceptor.wait(asio::ip::tcp::acceptor::wait_read); + + + + + + + +[endsect] + + + +[section:overload2 basic_socket_acceptor::wait (2 of 2 overloads)] + + +Wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. + + + asio::error_code wait( + wait_type w, + asio::error_code & ec); + + +This function is used to perform a blocking wait for an acceptor to enter a ready to read, write or error condition state. + + +[heading Parameters] + + +[variablelist + +[[w][Specifies the desired acceptor state.]] + +[[ec][Set to indicate what error occurred, if any.]] + +] + + +[heading Example] + +Waiting for an acceptor to become readable. + + asio::ip::tcp::acceptor acceptor(io_service); + ... + asio::error_code ec; + acceptor.wait(asio::ip::tcp::acceptor::wait_read, ec); + + + + + + + +[endsect] + + +[endsect] + [section:wait_type basic_socket_acceptor::wait_type] @@ -35054,7 +36065,7 @@ typename ``[link asio.reference.ConnectHandler ConnectHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_connect( const endpoint_type & peer_endpoint, - ConnectHandler handler); + ConnectHandler && handler); This function is used to asynchronously connect a socket to the specified remote endpoint. The function call always returns immediately. @@ -35122,7 +36133,7 @@ typename ``[link asio.reference.WaitHandler WaitHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( wait_type w, - WaitHandler handler); + WaitHandler && handler); This function is used to perform an asynchronous wait for a socket to enter a ready to read, write or error condition state. @@ -39945,7 +40956,7 @@ typename ``[link asio.reference.ConnectHandler ConnectHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_connect( const endpoint_type & peer_endpoint, - ConnectHandler handler); + ConnectHandler && handler); This function is used to asynchronously connect a socket to the specified remote endpoint. The function call always returns immediately. @@ -40011,7 +41022,7 @@ typename ``[link asio.reference.ReadHandler ReadHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_read_some( const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously read data from the stream socket. The function call always returns immediately. @@ -40067,7 +41078,7 @@ typename ``[link asio.reference.ReadHandler ReadHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.basic_stream_socket.async_receive.overload1 async_receive]``( const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); `` [''''»''' [link asio.reference.basic_stream_socket.async_receive.overload1 more...]]`` template< @@ -40076,7 +41087,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.basic_stream_socket.async_receive.overload2 async_receive]``( const MutableBufferSequence & buffers, socket_base::message_flags flags, - ReadHandler handler); + ReadHandler && handler); `` [''''»''' [link asio.reference.basic_stream_socket.async_receive.overload2 more...]]`` @@ -40091,7 +41102,7 @@ typename ``[link asio.reference.ReadHandler ReadHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_receive( const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously receive data from the stream socket. The function call always returns immediately. @@ -40149,7 +41160,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_receive( const MutableBufferSequence & buffers, socket_base::message_flags flags, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously receive data from the stream socket. The function call always returns immediately. @@ -40209,7 +41220,7 @@ typename ``[link asio.reference.WriteHandler WriteHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.basic_stream_socket.async_send.overload1 async_send]``( const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); `` [''''»''' [link asio.reference.basic_stream_socket.async_send.overload1 more...]]`` template< @@ -40218,7 +41229,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.basic_stream_socket.async_send.overload2 async_send]``( const ConstBufferSequence & buffers, socket_base::message_flags flags, - WriteHandler handler); + WriteHandler && handler); `` [''''»''' [link asio.reference.basic_stream_socket.async_send.overload2 more...]]`` @@ -40233,7 +41244,7 @@ typename ``[link asio.reference.WriteHandler WriteHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_send( const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); This function is used to asynchronously send data on the stream socket. The function call always returns immediately. @@ -40291,7 +41302,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_send( const ConstBufferSequence & buffers, socket_base::message_flags flags, - WriteHandler handler); + WriteHandler && handler); This function is used to asynchronously send data on the stream socket. The function call always returns immediately. @@ -40354,7 +41365,7 @@ typename ``[link asio.reference.WaitHandler WaitHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( wait_type w, - WaitHandler handler); + WaitHandler && handler); This function is used to perform an asynchronous wait for a socket to enter a ready to read, write or error condition state. @@ -40417,7 +41428,7 @@ typename ``[link asio.reference.WriteHandler WriteHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_write_some( const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); This function is used to asynchronously write data to the stream socket. The function call always returns immediately. @@ -45340,6 +46351,11 @@ ] [ + [[link asio.reference.basic_streambuf.capacity [*capacity]]] + [Get the current capacity of the basic_streambuf. ] + ] + + [ [[link asio.reference.basic_streambuf.commit [*commit]]] [Move characters from the output sequence to the input sequence. ] ] @@ -45475,6 +46491,27 @@ +[section:capacity basic_streambuf::capacity] + +[indexterm2 capacity..basic_streambuf] +Get the current capacity of the [link asio.reference.basic_streambuf `basic_streambuf`]. + + + std::size_t capacity() const; + + + +[heading Return Value] + +The current total capacity of the streambuf, i.e. for both the input sequence and output sequence. + + + + +[endsect] + + + [section:commit basic_streambuf::commit] [indexterm2 commit..basic_streambuf] @@ -45734,6 +46771,602 @@ [endsect] +[section:basic_streambuf_ref basic_streambuf_ref] + + +Adapts [link asio.reference.basic_streambuf `basic_streambuf`] to the dynamic buffer sequence type requirements. + + + template< + typename Allocator = std::allocator<char>> + class basic_streambuf_ref + + +[heading Types] +[table + [[Name][Description]] + + [ + + [[link asio.reference.basic_streambuf_ref.const_buffers_type [*const_buffers_type]]] + [The type used to represent the input sequence as a list of buffers. ] + + ] + + [ + + [[link asio.reference.basic_streambuf_ref.mutable_buffers_type [*mutable_buffers_type]]] + [The type used to represent the output sequence as a list of buffers. ] + + ] + +] + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.basic_streambuf_ref.basic_streambuf_ref [*basic_streambuf_ref]]] + [Construct a basic_streambuf_ref for the given basic_streambuf object. + + Copy construct a basic_streambuf_ref. + + Move construct a basic_streambuf_ref. ] + ] + + [ + [[link asio.reference.basic_streambuf_ref.capacity [*capacity]]] + [Get the current capacity of the dynamic buffer. ] + ] + + [ + [[link asio.reference.basic_streambuf_ref.commit [*commit]]] + [Move bytes from the output sequence to the input sequence. ] + ] + + [ + [[link asio.reference.basic_streambuf_ref.consume [*consume]]] + [Remove characters from the input sequence. ] + ] + + [ + [[link asio.reference.basic_streambuf_ref.data [*data]]] + [Get a list of buffers that represents the input sequence. ] + ] + + [ + [[link asio.reference.basic_streambuf_ref.max_size [*max_size]]] + [Get the maximum size of the dynamic buffer. ] + ] + + [ + [[link asio.reference.basic_streambuf_ref.prepare [*prepare]]] + [Get a list of buffers that represents the output sequence, with the given size. ] + ] + + [ + [[link asio.reference.basic_streambuf_ref.size [*size]]] + [Get the size of the input sequence. ] + ] + +] + +[heading Requirements] + +['Header: ][^asio/basic_streambuf.hpp] + +['Convenience header: ][^asio.hpp] + +[section:basic_streambuf_ref basic_streambuf_ref::basic_streambuf_ref] + +[indexterm2 basic_streambuf_ref..basic_streambuf_ref] +Construct a [link asio.reference.basic_streambuf_ref `basic_streambuf_ref`] for the given [link asio.reference.basic_streambuf `basic_streambuf`] object. + + + explicit ``[link asio.reference.basic_streambuf_ref.basic_streambuf_ref.overload1 basic_streambuf_ref]``( + basic_streambuf< Allocator > & sb); + `` [''''»''' [link asio.reference.basic_streambuf_ref.basic_streambuf_ref.overload1 more...]]`` + + +Copy construct a [link asio.reference.basic_streambuf_ref `basic_streambuf_ref`]. + + + ``[link asio.reference.basic_streambuf_ref.basic_streambuf_ref.overload2 basic_streambuf_ref]``( + const basic_streambuf_ref & other); + `` [''''»''' [link asio.reference.basic_streambuf_ref.basic_streambuf_ref.overload2 more...]]`` + + +Move construct a [link asio.reference.basic_streambuf_ref `basic_streambuf_ref`]. + + + ``[link asio.reference.basic_streambuf_ref.basic_streambuf_ref.overload3 basic_streambuf_ref]``( + basic_streambuf_ref && other); + `` [''''»''' [link asio.reference.basic_streambuf_ref.basic_streambuf_ref.overload3 more...]]`` + + +[section:overload1 basic_streambuf_ref::basic_streambuf_ref (1 of 3 overloads)] + + +Construct a [link asio.reference.basic_streambuf_ref `basic_streambuf_ref`] for the given [link asio.reference.basic_streambuf `basic_streambuf`] object. + + + basic_streambuf_ref( + basic_streambuf< Allocator > & sb); + + + +[endsect] + + + +[section:overload2 basic_streambuf_ref::basic_streambuf_ref (2 of 3 overloads)] + + +Copy construct a [link asio.reference.basic_streambuf_ref `basic_streambuf_ref`]. + + + basic_streambuf_ref( + const basic_streambuf_ref & other); + + + +[endsect] + + + +[section:overload3 basic_streambuf_ref::basic_streambuf_ref (3 of 3 overloads)] + + +Move construct a [link asio.reference.basic_streambuf_ref `basic_streambuf_ref`]. + + + basic_streambuf_ref( + basic_streambuf_ref && other); + + + +[endsect] + + +[endsect] + + +[section:capacity basic_streambuf_ref::capacity] + +[indexterm2 capacity..basic_streambuf_ref] +Get the current capacity of the dynamic buffer. + + + std::size_t capacity() const; + + + +[endsect] + + + +[section:commit basic_streambuf_ref::commit] + +[indexterm2 commit..basic_streambuf_ref] +Move bytes from the output sequence to the input sequence. + + + void commit( + std::size_t n); + + + +[endsect] + + + +[section:const_buffers_type basic_streambuf_ref::const_buffers_type] + +[indexterm2 const_buffers_type..basic_streambuf_ref] +The type used to represent the input sequence as a list of buffers. + + + typedef basic_streambuf< Allocator >::const_buffers_type const_buffers_type; + + +[heading Types] +[table + [[Name][Description]] + + [ + + [[link asio.reference.basic_streambuf.const_buffers_type [*const_buffers_type]]] + [The type used to represent the input sequence as a list of buffers. ] + + ] + + [ + + [[link asio.reference.basic_streambuf.mutable_buffers_type [*mutable_buffers_type]]] + [The type used to represent the output sequence as a list of buffers. ] + + ] + +] + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.basic_streambuf.basic_streambuf [*basic_streambuf]]] + [Construct a basic_streambuf object. ] + ] + + [ + [[link asio.reference.basic_streambuf.capacity [*capacity]]] + [Get the current capacity of the basic_streambuf. ] + ] + + [ + [[link asio.reference.basic_streambuf.commit [*commit]]] + [Move characters from the output sequence to the input sequence. ] + ] + + [ + [[link asio.reference.basic_streambuf.consume [*consume]]] + [Remove characters from the input sequence. ] + ] + + [ + [[link asio.reference.basic_streambuf.data [*data]]] + [Get a list of buffers that represents the input sequence. ] + ] + + [ + [[link asio.reference.basic_streambuf.max_size [*max_size]]] + [Get the maximum size of the basic_streambuf. ] + ] + + [ + [[link asio.reference.basic_streambuf.prepare [*prepare]]] + [Get a list of buffers that represents the output sequence, with the given size. ] + ] + + [ + [[link asio.reference.basic_streambuf.size [*size]]] + [Get the size of the input sequence. ] + ] + +] + +[heading Protected Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.basic_streambuf.overflow [*overflow]]] + [Override std::streambuf behaviour. ] + ] + + [ + [[link asio.reference.basic_streambuf.reserve [*reserve]]] + [] + ] + + [ + [[link asio.reference.basic_streambuf.underflow [*underflow]]] + [Override std::streambuf behaviour. ] + ] + +] + +The `basic_streambuf` class is derived from `std::streambuf` to associate the streambuf's input and output sequences with one or more character arrays. These character arrays are internal to the `basic_streambuf` object, but direct access to the array elements is provided to permit them to be used efficiently with I/O operations. Characters written to the output sequence of a `basic_streambuf` object are appended to the input sequence of the same object. + +The `basic_streambuf` class's public interface is intended to permit the following implementation strategies: + + +* A single contiguous character array, which is reallocated as necessary to accommodate changes in the size of the character sequence. This is the implementation approach currently used in Asio. + + +* A sequence of one or more character arrays, where each array is of the same size. Additional character array objects are appended to the sequence to accommodate changes in the size of the character sequence. + + +* A sequence of one or more character arrays of varying sizes. Additional character array objects are appended to the sequence to accommodate changes in the size of the character sequence. + +The constructor for [link asio.reference.basic_streambuf `basic_streambuf`] accepts a `size_t` argument specifying the maximum of the sum of the sizes of the input sequence and output sequence. During the lifetime of the `basic_streambuf` object, the following invariant holds: + + size() <= max_size() + + +Any member function that would, if successful, cause the invariant to be violated shall throw an exception of class `std::length_error`. + +The constructor for `basic_streambuf` takes an Allocator argument. A copy of this argument is used for any memory allocation performed, by the constructor and by all member functions, during the lifetime of each `basic_streambuf` object. + + +[heading Examples] + +Writing directly from an streambuf to a socket: + + asio::streambuf b; + std::ostream os(&b); + os << "Hello, World!\n"; + + // try sending some data in input sequence + size_t n = sock.send(b.data()); + + b.consume(n); // sent data is removed from input sequence + + + + +Reading from a socket directly into a streambuf: + + asio::streambuf b; + + // reserve 512 bytes in output sequence + asio::streambuf::mutable_buffers_type bufs = b.prepare(512); + + size_t n = sock.receive(bufs); + + // received data is "committed" from output sequence to input sequence + b.commit(n); + + std::istream is(&b); + std::string s; + is >> s; + + + + + +[heading Requirements] + +['Header: ][^asio/basic_streambuf.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:consume basic_streambuf_ref::consume] + +[indexterm2 consume..basic_streambuf_ref] +Remove characters from the input sequence. + + + void consume( + std::size_t n); + + + +[endsect] + + + +[section:data basic_streambuf_ref::data] + +[indexterm2 data..basic_streambuf_ref] +Get a list of buffers that represents the input sequence. + + + const_buffers_type data() const; + + + +[endsect] + + + +[section:max_size basic_streambuf_ref::max_size] + +[indexterm2 max_size..basic_streambuf_ref] +Get the maximum size of the dynamic buffer. + + + std::size_t max_size() const; + + + +[endsect] + + + +[section:mutable_buffers_type basic_streambuf_ref::mutable_buffers_type] + +[indexterm2 mutable_buffers_type..basic_streambuf_ref] +The type used to represent the output sequence as a list of buffers. + + + typedef basic_streambuf< Allocator >::mutable_buffers_type mutable_buffers_type; + + +[heading Types] +[table + [[Name][Description]] + + [ + + [[link asio.reference.basic_streambuf.const_buffers_type [*const_buffers_type]]] + [The type used to represent the input sequence as a list of buffers. ] + + ] + + [ + + [[link asio.reference.basic_streambuf.mutable_buffers_type [*mutable_buffers_type]]] + [The type used to represent the output sequence as a list of buffers. ] + + ] + +] + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.basic_streambuf.basic_streambuf [*basic_streambuf]]] + [Construct a basic_streambuf object. ] + ] + + [ + [[link asio.reference.basic_streambuf.capacity [*capacity]]] + [Get the current capacity of the basic_streambuf. ] + ] + + [ + [[link asio.reference.basic_streambuf.commit [*commit]]] + [Move characters from the output sequence to the input sequence. ] + ] + + [ + [[link asio.reference.basic_streambuf.consume [*consume]]] + [Remove characters from the input sequence. ] + ] + + [ + [[link asio.reference.basic_streambuf.data [*data]]] + [Get a list of buffers that represents the input sequence. ] + ] + + [ + [[link asio.reference.basic_streambuf.max_size [*max_size]]] + [Get the maximum size of the basic_streambuf. ] + ] + + [ + [[link asio.reference.basic_streambuf.prepare [*prepare]]] + [Get a list of buffers that represents the output sequence, with the given size. ] + ] + + [ + [[link asio.reference.basic_streambuf.size [*size]]] + [Get the size of the input sequence. ] + ] + +] + +[heading Protected Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.basic_streambuf.overflow [*overflow]]] + [Override std::streambuf behaviour. ] + ] + + [ + [[link asio.reference.basic_streambuf.reserve [*reserve]]] + [] + ] + + [ + [[link asio.reference.basic_streambuf.underflow [*underflow]]] + [Override std::streambuf behaviour. ] + ] + +] + +The `basic_streambuf` class is derived from `std::streambuf` to associate the streambuf's input and output sequences with one or more character arrays. These character arrays are internal to the `basic_streambuf` object, but direct access to the array elements is provided to permit them to be used efficiently with I/O operations. Characters written to the output sequence of a `basic_streambuf` object are appended to the input sequence of the same object. + +The `basic_streambuf` class's public interface is intended to permit the following implementation strategies: + + +* A single contiguous character array, which is reallocated as necessary to accommodate changes in the size of the character sequence. This is the implementation approach currently used in Asio. + + +* A sequence of one or more character arrays, where each array is of the same size. Additional character array objects are appended to the sequence to accommodate changes in the size of the character sequence. + + +* A sequence of one or more character arrays of varying sizes. Additional character array objects are appended to the sequence to accommodate changes in the size of the character sequence. + +The constructor for [link asio.reference.basic_streambuf `basic_streambuf`] accepts a `size_t` argument specifying the maximum of the sum of the sizes of the input sequence and output sequence. During the lifetime of the `basic_streambuf` object, the following invariant holds: + + size() <= max_size() + + +Any member function that would, if successful, cause the invariant to be violated shall throw an exception of class `std::length_error`. + +The constructor for `basic_streambuf` takes an Allocator argument. A copy of this argument is used for any memory allocation performed, by the constructor and by all member functions, during the lifetime of each `basic_streambuf` object. + + +[heading Examples] + +Writing directly from an streambuf to a socket: + + asio::streambuf b; + std::ostream os(&b); + os << "Hello, World!\n"; + + // try sending some data in input sequence + size_t n = sock.send(b.data()); + + b.consume(n); // sent data is removed from input sequence + + + + +Reading from a socket directly into a streambuf: + + asio::streambuf b; + + // reserve 512 bytes in output sequence + asio::streambuf::mutable_buffers_type bufs = b.prepare(512); + + size_t n = sock.receive(bufs); + + // received data is "committed" from output sequence to input sequence + b.commit(n); + + std::istream is(&b); + std::string s; + is >> s; + + + + + +[heading Requirements] + +['Header: ][^asio/basic_streambuf.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:prepare basic_streambuf_ref::prepare] + +[indexterm2 prepare..basic_streambuf_ref] +Get a list of buffers that represents the output sequence, with the given size. + + + mutable_buffers_type prepare( + std::size_t n); + + + +[endsect] + + + +[section:size basic_streambuf_ref::size] + +[indexterm2 size..basic_streambuf_ref] +Get the size of the input sequence. + + + std::size_t size() const; + + + +[endsect] + + + +[endsect] + [section:basic_waitable_timer basic_waitable_timer] @@ -46010,7 +47643,7 @@ template< typename ``[link asio.reference.WaitHandler WaitHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( - WaitHandler handler); + WaitHandler && handler); This function may be used to initiate an asynchronous wait against the timer. It always returns immediately. @@ -51018,7 +52651,7 @@ template< typename ``[link asio.reference.ReadHandler ReadHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_fill( - ReadHandler handler); + ReadHandler && handler); @@ -51037,7 +52670,7 @@ typename ``[link asio.reference.ReadHandler ReadHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_read_some( const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); @@ -51056,7 +52689,7 @@ typename ``[link asio.reference.WriteHandler WriteHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_write_some( const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); @@ -51721,7 +53354,7 @@ template< typename ``[link asio.reference.ReadHandler ReadHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_fill( - ReadHandler handler); + ReadHandler && handler); @@ -51738,7 +53371,7 @@ template< typename ``[link asio.reference.WriteHandler WriteHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_flush( - WriteHandler handler); + WriteHandler && handler); @@ -51757,7 +53390,7 @@ typename ``[link asio.reference.ReadHandler ReadHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_read_some( const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); @@ -51776,7 +53409,7 @@ typename ``[link asio.reference.WriteHandler WriteHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_write_some( const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); @@ -52476,7 +54109,7 @@ template< typename ``[link asio.reference.WriteHandler WriteHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_flush( - WriteHandler handler); + WriteHandler && handler); @@ -52495,7 +54128,7 @@ typename ``[link asio.reference.ReadHandler ReadHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_read_some( const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); @@ -52514,7 +54147,7 @@ typename ``[link asio.reference.WriteHandler WriteHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_write_some( const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); @@ -55716,7 +57349,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_connect( implementation_type & impl, const endpoint_type & peer_endpoint, - ConnectHandler handler); + ConnectHandler && handler); @@ -55737,7 +57370,7 @@ implementation_type & impl, const MutableBufferSequence & buffers, socket_base::message_flags flags, - ReadHandler handler); + ReadHandler && handler); @@ -55759,7 +57392,7 @@ const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, socket_base::message_flags flags, - ReadHandler handler); + ReadHandler && handler); @@ -55780,7 +57413,7 @@ implementation_type & impl, const ConstBufferSequence & buffers, socket_base::message_flags flags, - WriteHandler handler); + WriteHandler && handler); @@ -55802,7 +57435,7 @@ const ConstBufferSequence & buffers, const endpoint_type & destination, socket_base::message_flags flags, - WriteHandler handler); + WriteHandler && handler); @@ -55821,7 +57454,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( implementation_type & impl, socket_base::wait_type w, - WaitHandler handler); + WaitHandler && handler); @@ -56868,7 +58501,7 @@ typename ``[link asio.reference.WaitHandler WaitHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( implementation_type & impl, - WaitHandler handler); + WaitHandler && handler); @@ -57201,7 +58834,7 @@ template< typename CompletionToken> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.defer.overload1 defer]``( - CompletionToken token); + CompletionToken && token); `` [''''»''' [link asio.reference.defer.overload1 more...]]`` template< @@ -57209,7 +58842,7 @@ typename CompletionToken> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.defer.overload2 defer]``( const Executor & ex, - CompletionToken token, + CompletionToken && token, typename enable_if< is_executor< Executor >::value >::type * = 0); `` [''''»''' [link asio.reference.defer.overload2 more...]]`` @@ -57218,7 +58851,7 @@ typename CompletionToken> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.defer.overload3 defer]``( ExecutionContext & ctx, - CompletionToken token, + CompletionToken && token, typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type * = 0); `` [''''»''' [link asio.reference.defer.overload3 more...]]`` @@ -57238,7 +58871,7 @@ template< typename CompletionToken> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` defer( - CompletionToken token); + CompletionToken && token); This function submits an object for execution using the object's associated executor. The function object is queued for execution, and is never called from the current thread prior to returning from `defer()`. @@ -57281,7 +58914,7 @@ typename CompletionToken> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` defer( const Executor & ex, - CompletionToken token, + CompletionToken && token, typename enable_if< is_executor< Executor >::value >::type * = 0); @@ -57331,7 +58964,7 @@ typename CompletionToken> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` defer( ExecutionContext & ctx, - CompletionToken token, + CompletionToken && token, typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type * = 0); @@ -57357,7 +58990,7 @@ template< typename CompletionToken> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.dispatch.overload1 dispatch]``( - CompletionToken token); + CompletionToken && token); `` [''''»''' [link asio.reference.dispatch.overload1 more...]]`` template< @@ -57365,7 +58998,7 @@ typename CompletionToken> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.dispatch.overload2 dispatch]``( const Executor & ex, - CompletionToken token, + CompletionToken && token, typename enable_if< is_executor< Executor >::value >::type * = 0); `` [''''»''' [link asio.reference.dispatch.overload2 more...]]`` @@ -57374,7 +59007,7 @@ typename CompletionToken> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.dispatch.overload3 dispatch]``( ExecutionContext & ctx, - CompletionToken token, + CompletionToken && token, typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type * = 0); `` [''''»''' [link asio.reference.dispatch.overload3 more...]]`` @@ -57394,7 +59027,7 @@ template< typename CompletionToken> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` dispatch( - CompletionToken token); + CompletionToken && token); This function submits an object for execution using the object's associated executor. The function object is queued for execution, and is never called from the current thread prior to returning from `dispatch()`. @@ -57437,7 +59070,7 @@ typename CompletionToken> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` dispatch( const Executor & ex, - CompletionToken token, + CompletionToken && token, typename enable_if< is_executor< Executor >::value >::type * = 0); @@ -57487,7 +59120,7 @@ typename CompletionToken> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` dispatch( ExecutionContext & ctx, - CompletionToken token, + CompletionToken && token, typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type * = 0); @@ -57504,6 +59137,1129 @@ [endsect] +[section:dynamic_buffer dynamic_buffer] + +[indexterm1 dynamic_buffer] +The `asio::dynamic_buffer` function is used to create a dynamically resized buffer from a `std::basic_string` or `std::vector`. + + + template< + typename Elem, + typename Traits, + typename Allocator> + dynamic_string_buffer< Elem, Traits, Allocator > ``[link asio.reference.dynamic_buffer.overload1 dynamic_buffer]``( + std::basic_string< Elem, Traits, Allocator > & data); + `` [''''»''' [link asio.reference.dynamic_buffer.overload1 more...]]`` + + template< + typename Elem, + typename Traits, + typename Allocator> + dynamic_string_buffer< Elem, Traits, Allocator > ``[link asio.reference.dynamic_buffer.overload2 dynamic_buffer]``( + std::basic_string< Elem, Traits, Allocator > & data, + std::size_t max_size); + `` [''''»''' [link asio.reference.dynamic_buffer.overload2 more...]]`` + + template< + typename Elem, + typename Allocator> + dynamic_vector_buffer< Elem, Allocator > ``[link asio.reference.dynamic_buffer.overload3 dynamic_buffer]``( + std::vector< Elem, Allocator > & data); + `` [''''»''' [link asio.reference.dynamic_buffer.overload3 more...]]`` + + template< + typename Elem, + typename Allocator> + dynamic_vector_buffer< Elem, Allocator > ``[link asio.reference.dynamic_buffer.overload4 dynamic_buffer]``( + std::vector< Elem, Allocator > & data, + std::size_t max_size); + `` [''''»''' [link asio.reference.dynamic_buffer.overload4 more...]]`` + +[heading Requirements] + +['Header: ][^asio/buffer.hpp] + +['Convenience header: ][^asio.hpp] + + +[section:overload1 dynamic_buffer (1 of 4 overloads)] + + +Create a new dynamic buffer that represents the given string. + + + template< + typename Elem, + typename Traits, + typename Allocator> + dynamic_string_buffer< Elem, Traits, Allocator > dynamic_buffer( + std::basic_string< Elem, Traits, Allocator > & data); + + + +[heading Return Value] + +`dynamic_string_buffer<Elem, Traits, Allocator>(data)`. + + + + +[endsect] + + + +[section:overload2 dynamic_buffer (2 of 4 overloads)] + + +Create a new dynamic buffer that represents the given string. + + + template< + typename Elem, + typename Traits, + typename Allocator> + dynamic_string_buffer< Elem, Traits, Allocator > dynamic_buffer( + std::basic_string< Elem, Traits, Allocator > & data, + std::size_t max_size); + + + +[heading Return Value] + +`dynamic_string_buffer<Elem, Traits, Allocator>(data, max_size)`. + + + + +[endsect] + + + +[section:overload3 dynamic_buffer (3 of 4 overloads)] + + +Create a new dynamic buffer that represents the given vector. + + + template< + typename Elem, + typename Allocator> + dynamic_vector_buffer< Elem, Allocator > dynamic_buffer( + std::vector< Elem, Allocator > & data); + + + +[heading Return Value] + +`dynamic_vector_buffer<Elem, Allocator>(data)`. + + + + +[endsect] + + + +[section:overload4 dynamic_buffer (4 of 4 overloads)] + + +Create a new dynamic buffer that represents the given vector. + + + template< + typename Elem, + typename Allocator> + dynamic_vector_buffer< Elem, Allocator > dynamic_buffer( + std::vector< Elem, Allocator > & data, + std::size_t max_size); + + + +[heading Return Value] + +`dynamic_vector_buffer<Elem, Allocator>(data, max_size)`. + + + + +[endsect] + + +[endsect] + +[section:dynamic_string_buffer dynamic_string_buffer] + + +Adapt a basic\_string to the DynamicBufferSequence requirements. + + + template< + typename Elem, + typename Traits, + typename Allocator> + class dynamic_string_buffer + + +[heading Types] +[table + [[Name][Description]] + + [ + + [[link asio.reference.dynamic_string_buffer.const_buffers_type [*const_buffers_type]]] + [The type used to represent the input sequence as a list of buffers. ] + + ] + + [ + + [[link asio.reference.dynamic_string_buffer.mutable_buffers_type [*mutable_buffers_type]]] + [The type used to represent the output sequence as a list of buffers. ] + + ] + +] + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.dynamic_string_buffer.capacity [*capacity]]] + [Get the current capacity of the dynamic buffer. ] + ] + + [ + [[link asio.reference.dynamic_string_buffer.commit [*commit]]] + [Move bytes from the output sequence to the input sequence. ] + ] + + [ + [[link asio.reference.dynamic_string_buffer.consume [*consume]]] + [Remove characters from the input sequence. ] + ] + + [ + [[link asio.reference.dynamic_string_buffer.data [*data]]] + [Get a list of buffers that represents the input sequence. ] + ] + + [ + [[link asio.reference.dynamic_string_buffer.dynamic_string_buffer [*dynamic_string_buffer]]] + [Construct a dynamic buffer from a string. + + Move construct a dynamic buffer. ] + ] + + [ + [[link asio.reference.dynamic_string_buffer.max_size [*max_size]]] + [Get the maximum size of the dynamic buffer. ] + ] + + [ + [[link asio.reference.dynamic_string_buffer.prepare [*prepare]]] + [Get a list of buffers that represents the output sequence, with the given size. ] + ] + + [ + [[link asio.reference.dynamic_string_buffer.size [*size]]] + [Get the size of the input sequence. ] + ] + +] + +Requires that `sizeof(Elem) == 1`. + +[heading Requirements] + +['Header: ][^asio/buffer.hpp] + +['Convenience header: ][^asio.hpp] + + +[section:capacity dynamic_string_buffer::capacity] + +[indexterm2 capacity..dynamic_string_buffer] +Get the current capacity of the dynamic buffer. + + + std::size_t capacity() const; + + + +[heading Return Value] + +The current total capacity of the buffer, i.e. for both the input sequence and output sequence. + + + + +[endsect] + + + +[section:commit dynamic_string_buffer::commit] + +[indexterm2 commit..dynamic_string_buffer] +Move bytes from the output sequence to the input sequence. + + + void commit( + std::size_t n); + + + +[heading Parameters] + + +[variablelist + +[[n][The number of bytes to append from the start of the output sequence to the end of the input sequence. The remainder of the output sequence is discarded.]] + +] + +Requires a preceding call `prepare(x)` where `x >= n`, and no intervening operations that modify the input or output sequence. + + +[heading Remarks] + +If `n` is greater than the size of the output sequence, the entire output sequence is moved to the input sequence and no error is issued. + + + + +[endsect] + + + +[section:const_buffers_type dynamic_string_buffer::const_buffers_type] + +[indexterm2 const_buffers_type..dynamic_string_buffer] +The type used to represent the input sequence as a list of buffers. + + + typedef const_buffers_1 const_buffers_type; + + +[heading Types] +[table + [[Name][Description]] + + [ + + [[link asio.reference.const_buffers_1.const_iterator [*const_iterator]]] + [A random-access iterator type that may be used to read elements. ] + + ] + + [ + + [[link asio.reference.const_buffers_1.value_type [*value_type]]] + [The type for each element in the list of buffers. ] + + ] + +] + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.const_buffers_1.begin [*begin]]] + [Get a random-access iterator to the first element. ] + ] + + [ + [[link asio.reference.const_buffers_1.const_buffers_1 [*const_buffers_1]]] + [Construct to represent a given memory range. + + Construct to represent a single non-modifiable buffer. ] + ] + + [ + [[link asio.reference.const_buffers_1.end [*end]]] + [Get a random-access iterator for one past the last element. ] + ] + +] + +[heading Related Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.const_buffers_1.operator_plus_ [*operator+]]] + [Create a new non-modifiable buffer that is offset from the start of another. ] + ] + +] + + +[heading Requirements] + +['Header: ][^asio/buffer.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:consume dynamic_string_buffer::consume] + +[indexterm2 consume..dynamic_string_buffer] +Remove characters from the input sequence. + + + void consume( + std::size_t n); + + +Removes `n` characters from the beginning of the input sequence. + + +[heading Remarks] + +If `n` is greater than the size of the input sequence, the entire input sequence is consumed and no error is issued. + + + + +[endsect] + + + +[section:data dynamic_string_buffer::data] + +[indexterm2 data..dynamic_string_buffer] +Get a list of buffers that represents the input sequence. + + + const_buffers_type data() const; + + + +[heading Return Value] + +An object of type `const_buffers_type` that satisfies ConstBufferSequence requirements, representing the basic\_string memory in input sequence. + + +[heading Remarks] + +The returned object is invalidated by any `dynamic_string_buffer` or `basic_string` member function that modifies the input sequence or output sequence. + + + + +[endsect] + + +[section:dynamic_string_buffer dynamic_string_buffer::dynamic_string_buffer] + +[indexterm2 dynamic_string_buffer..dynamic_string_buffer] +Construct a dynamic buffer from a string. + + + explicit ``[link asio.reference.dynamic_string_buffer.dynamic_string_buffer.overload1 dynamic_string_buffer]``( + std::basic_string< Elem, Traits, Allocator > & s, + std::size_t maximum_size = (std::numeric_limits< std::size_t >::max)()); + `` [''''»''' [link asio.reference.dynamic_string_buffer.dynamic_string_buffer.overload1 more...]]`` + + +Move construct a dynamic buffer. + + + ``[link asio.reference.dynamic_string_buffer.dynamic_string_buffer.overload2 dynamic_string_buffer]``( + dynamic_string_buffer && other); + `` [''''»''' [link asio.reference.dynamic_string_buffer.dynamic_string_buffer.overload2 more...]]`` + + +[section:overload1 dynamic_string_buffer::dynamic_string_buffer (1 of 2 overloads)] + + +Construct a dynamic buffer from a string. + + + dynamic_string_buffer( + std::basic_string< Elem, Traits, Allocator > & s, + std::size_t maximum_size = (std::numeric_limits< std::size_t >::max)()); + + + +[heading Parameters] + + +[variablelist + +[[s][The string to be used as backing storage for the dynamic buffer. Any existing data in the string is treated as the dynamic buffer's input sequence. The object stores a reference to the string and the user is responsible for ensuring that the string object remains valid until the [link asio.reference.dynamic_string_buffer `dynamic_string_buffer`] object is destroyed.]] + +[[maximum_size][Specifies a maximum size for the buffer, in bytes. ]] + +] + + + + +[endsect] + + + +[section:overload2 dynamic_string_buffer::dynamic_string_buffer (2 of 2 overloads)] + + +Move construct a dynamic buffer. + + + dynamic_string_buffer( + dynamic_string_buffer && other); + + + +[endsect] + + +[endsect] + + +[section:max_size dynamic_string_buffer::max_size] + +[indexterm2 max_size..dynamic_string_buffer] +Get the maximum size of the dynamic buffer. + + + std::size_t max_size() const; + + + +[heading Return Value] + +The allowed maximum of the sum of the sizes of the input sequence and output sequence. + + + + +[endsect] + + + +[section:mutable_buffers_type dynamic_string_buffer::mutable_buffers_type] + +[indexterm2 mutable_buffers_type..dynamic_string_buffer] +The type used to represent the output sequence as a list of buffers. + + + typedef mutable_buffers_1 mutable_buffers_type; + + +[heading Types] +[table + [[Name][Description]] + + [ + + [[link asio.reference.mutable_buffers_1.const_iterator [*const_iterator]]] + [A random-access iterator type that may be used to read elements. ] + + ] + + [ + + [[link asio.reference.mutable_buffers_1.value_type [*value_type]]] + [The type for each element in the list of buffers. ] + + ] + +] + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.mutable_buffers_1.begin [*begin]]] + [Get a random-access iterator to the first element. ] + ] + + [ + [[link asio.reference.mutable_buffers_1.end [*end]]] + [Get a random-access iterator for one past the last element. ] + ] + + [ + [[link asio.reference.mutable_buffers_1.mutable_buffers_1 [*mutable_buffers_1]]] + [Construct to represent a given memory range. + + Construct to represent a single modifiable buffer. ] + ] + +] + +[heading Related Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.mutable_buffers_1.operator_plus_ [*operator+]]] + [Create a new modifiable buffer that is offset from the start of another. ] + ] + +] + + +[heading Requirements] + +['Header: ][^asio/buffer.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:prepare dynamic_string_buffer::prepare] + +[indexterm2 prepare..dynamic_string_buffer] +Get a list of buffers that represents the output sequence, with the given size. + + + mutable_buffers_type prepare( + std::size_t n); + + +Ensures that the output sequence can accommodate `n` bytes, resizing the basic\_string object as necessary. + + +[heading Return Value] + +An object of type `mutable_buffers_type` that satisfies MutableBufferSequence requirements, representing basic\_string memory at the start of the output sequence of size `n`. + + +[heading Exceptions] + + +[variablelist + +[[std::length_error][If `size() + n > max_size()`.]] + +] + + +[heading Remarks] + +The returned object is invalidated by any `dynamic_string_buffer` or `basic_string` member function that modifies the input sequence or output sequence. + + + + +[endsect] + + + +[section:size dynamic_string_buffer::size] + +[indexterm2 size..dynamic_string_buffer] +Get the size of the input sequence. + + + std::size_t size() const; + + + +[endsect] + + + +[endsect] + +[section:dynamic_vector_buffer dynamic_vector_buffer] + + +Adapt a vector to the DynamicBufferSequence requirements. + + + template< + typename Elem, + typename Allocator> + class dynamic_vector_buffer + + +[heading Types] +[table + [[Name][Description]] + + [ + + [[link asio.reference.dynamic_vector_buffer.const_buffers_type [*const_buffers_type]]] + [The type used to represent the input sequence as a list of buffers. ] + + ] + + [ + + [[link asio.reference.dynamic_vector_buffer.mutable_buffers_type [*mutable_buffers_type]]] + [The type used to represent the output sequence as a list of buffers. ] + + ] + +] + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.dynamic_vector_buffer.capacity [*capacity]]] + [Get the current capacity of the dynamic buffer. ] + ] + + [ + [[link asio.reference.dynamic_vector_buffer.commit [*commit]]] + [Move bytes from the output sequence to the input sequence. ] + ] + + [ + [[link asio.reference.dynamic_vector_buffer.consume [*consume]]] + [Remove characters from the input sequence. ] + ] + + [ + [[link asio.reference.dynamic_vector_buffer.data [*data]]] + [Get a list of buffers that represents the input sequence. ] + ] + + [ + [[link asio.reference.dynamic_vector_buffer.dynamic_vector_buffer [*dynamic_vector_buffer]]] + [Construct a dynamic buffer from a string. + + Move construct a dynamic buffer. ] + ] + + [ + [[link asio.reference.dynamic_vector_buffer.max_size [*max_size]]] + [Get the maximum size of the dynamic buffer. ] + ] + + [ + [[link asio.reference.dynamic_vector_buffer.prepare [*prepare]]] + [Get a list of buffers that represents the output sequence, with the given size. ] + ] + + [ + [[link asio.reference.dynamic_vector_buffer.size [*size]]] + [Get the size of the input sequence. ] + ] + +] + +Requires that `sizeof(Elem) == 1`. + +[heading Requirements] + +['Header: ][^asio/buffer.hpp] + +['Convenience header: ][^asio.hpp] + + +[section:capacity dynamic_vector_buffer::capacity] + +[indexterm2 capacity..dynamic_vector_buffer] +Get the current capacity of the dynamic buffer. + + + std::size_t capacity() const; + + + +[heading Return Value] + +The current total capacity of the buffer, i.e. for both the input sequence and output sequence. + + + + +[endsect] + + + +[section:commit dynamic_vector_buffer::commit] + +[indexterm2 commit..dynamic_vector_buffer] +Move bytes from the output sequence to the input sequence. + + + void commit( + std::size_t n); + + + +[heading Parameters] + + +[variablelist + +[[n][The number of bytes to append from the start of the output sequence to the end of the input sequence. The remainder of the output sequence is discarded.]] + +] + +Requires a preceding call `prepare(x)` where `x >= n`, and no intervening operations that modify the input or output sequence. + + +[heading Remarks] + +If `n` is greater than the size of the output sequence, the entire output sequence is moved to the input sequence and no error is issued. + + + + +[endsect] + + + +[section:const_buffers_type dynamic_vector_buffer::const_buffers_type] + +[indexterm2 const_buffers_type..dynamic_vector_buffer] +The type used to represent the input sequence as a list of buffers. + + + typedef const_buffers_1 const_buffers_type; + + +[heading Types] +[table + [[Name][Description]] + + [ + + [[link asio.reference.const_buffers_1.const_iterator [*const_iterator]]] + [A random-access iterator type that may be used to read elements. ] + + ] + + [ + + [[link asio.reference.const_buffers_1.value_type [*value_type]]] + [The type for each element in the list of buffers. ] + + ] + +] + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.const_buffers_1.begin [*begin]]] + [Get a random-access iterator to the first element. ] + ] + + [ + [[link asio.reference.const_buffers_1.const_buffers_1 [*const_buffers_1]]] + [Construct to represent a given memory range. + + Construct to represent a single non-modifiable buffer. ] + ] + + [ + [[link asio.reference.const_buffers_1.end [*end]]] + [Get a random-access iterator for one past the last element. ] + ] + +] + +[heading Related Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.const_buffers_1.operator_plus_ [*operator+]]] + [Create a new non-modifiable buffer that is offset from the start of another. ] + ] + +] + + +[heading Requirements] + +['Header: ][^asio/buffer.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:consume dynamic_vector_buffer::consume] + +[indexterm2 consume..dynamic_vector_buffer] +Remove characters from the input sequence. + + + void consume( + std::size_t n); + + +Removes `n` characters from the beginning of the input sequence. + + +[heading Remarks] + +If `n` is greater than the size of the input sequence, the entire input sequence is consumed and no error is issued. + + + + +[endsect] + + + +[section:data dynamic_vector_buffer::data] + +[indexterm2 data..dynamic_vector_buffer] +Get a list of buffers that represents the input sequence. + + + const_buffers_type data() const; + + + +[heading Return Value] + +An object of type `const_buffers_type` that satisfies ConstBufferSequence requirements, representing the basic\_string memory in input sequence. + + +[heading Remarks] + +The returned object is invalidated by any `dynamic_vector_buffer` or `basic_string` member function that modifies the input sequence or output sequence. + + + + +[endsect] + + +[section:dynamic_vector_buffer dynamic_vector_buffer::dynamic_vector_buffer] + +[indexterm2 dynamic_vector_buffer..dynamic_vector_buffer] +Construct a dynamic buffer from a string. + + + explicit ``[link asio.reference.dynamic_vector_buffer.dynamic_vector_buffer.overload1 dynamic_vector_buffer]``( + std::vector< Elem, Allocator > & v, + std::size_t maximum_size = (std::numeric_limits< std::size_t >::max)()); + `` [''''»''' [link asio.reference.dynamic_vector_buffer.dynamic_vector_buffer.overload1 more...]]`` + + +Move construct a dynamic buffer. + + + ``[link asio.reference.dynamic_vector_buffer.dynamic_vector_buffer.overload2 dynamic_vector_buffer]``( + dynamic_vector_buffer && other); + `` [''''»''' [link asio.reference.dynamic_vector_buffer.dynamic_vector_buffer.overload2 more...]]`` + + +[section:overload1 dynamic_vector_buffer::dynamic_vector_buffer (1 of 2 overloads)] + + +Construct a dynamic buffer from a string. + + + dynamic_vector_buffer( + std::vector< Elem, Allocator > & v, + std::size_t maximum_size = (std::numeric_limits< std::size_t >::max)()); + + + +[heading Parameters] + + +[variablelist + +[[v][The vector to be used as backing storage for the dynamic buffer. Any existing data in the vector is treated as the dynamic buffer's input sequence. The object stores a reference to the vector and the user is responsible for ensuring that the vector object remains valid until the [link asio.reference.dynamic_vector_buffer `dynamic_vector_buffer`] object is destroyed.]] + +[[maximum_size][Specifies a maximum size for the buffer, in bytes. ]] + +] + + + + +[endsect] + + + +[section:overload2 dynamic_vector_buffer::dynamic_vector_buffer (2 of 2 overloads)] + + +Move construct a dynamic buffer. + + + dynamic_vector_buffer( + dynamic_vector_buffer && other); + + + +[endsect] + + +[endsect] + + +[section:max_size dynamic_vector_buffer::max_size] + +[indexterm2 max_size..dynamic_vector_buffer] +Get the maximum size of the dynamic buffer. + + + std::size_t max_size() const; + + + +[heading Return Value] + +The allowed maximum of the sum of the sizes of the input sequence and output sequence. + + + + +[endsect] + + + +[section:mutable_buffers_type dynamic_vector_buffer::mutable_buffers_type] + +[indexterm2 mutable_buffers_type..dynamic_vector_buffer] +The type used to represent the output sequence as a list of buffers. + + + typedef mutable_buffers_1 mutable_buffers_type; + + +[heading Types] +[table + [[Name][Description]] + + [ + + [[link asio.reference.mutable_buffers_1.const_iterator [*const_iterator]]] + [A random-access iterator type that may be used to read elements. ] + + ] + + [ + + [[link asio.reference.mutable_buffers_1.value_type [*value_type]]] + [The type for each element in the list of buffers. ] + + ] + +] + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.mutable_buffers_1.begin [*begin]]] + [Get a random-access iterator to the first element. ] + ] + + [ + [[link asio.reference.mutable_buffers_1.end [*end]]] + [Get a random-access iterator for one past the last element. ] + ] + + [ + [[link asio.reference.mutable_buffers_1.mutable_buffers_1 [*mutable_buffers_1]]] + [Construct to represent a given memory range. + + Construct to represent a single modifiable buffer. ] + ] + +] + +[heading Related Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.mutable_buffers_1.operator_plus_ [*operator+]]] + [Create a new modifiable buffer that is offset from the start of another. ] + ] + +] + + +[heading Requirements] + +['Header: ][^asio/buffer.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:prepare dynamic_vector_buffer::prepare] + +[indexterm2 prepare..dynamic_vector_buffer] +Get a list of buffers that represents the output sequence, with the given size. + + + mutable_buffers_type prepare( + std::size_t n); + + +Ensures that the output sequence can accommodate `n` bytes, resizing the basic\_string object as necessary. + + +[heading Return Value] + +An object of type `mutable_buffers_type` that satisfies MutableBufferSequence requirements, representing basic\_string memory at the start of the output sequence of size `n`. + + +[heading Exceptions] + + +[variablelist + +[[std::length_error][If `size() + n > max_size()`.]] + +] + + +[heading Remarks] + +The returned object is invalidated by any `dynamic_vector_buffer` or `basic_string` member function that modifies the input sequence or output sequence. + + + + +[endsect] + + + +[section:size dynamic_vector_buffer::size] + +[indexterm2 size..dynamic_vector_buffer] +Get the size of the input sequence. + + + std::size_t size() const; + + + +[endsect] + + + +[endsect] + [section:error__addrinfo_category error::addrinfo_category] @@ -57590,6 +60346,7 @@ [indexterm2 no_memory..error::basic_errors] [indexterm2 no_permission..error::basic_errors] [indexterm2 no_protocol_option..error::basic_errors] +[indexterm2 no_such_device..error::basic_errors] [indexterm2 not_connected..error::basic_errors] [indexterm2 not_socket..error::basic_errors] [indexterm2 operation_aborted..error::basic_errors] @@ -57728,6 +60485,11 @@ ] [ + [no_such_device] + [No such device. ] + ] + + [ [not_connected] [Transport endpoint is not connected. ] ] @@ -58694,7 +61456,7 @@ [ [[link asio.reference.execution_context.add_service [*add_service]]] - [Add a service object to the execution_context. ] + [(Deprecated: Use make_service().) Add a service object to the execution_context. ] ] [ @@ -58703,6 +61465,11 @@ ] [ + [[link asio.reference.execution_context.make_service [*make_service]]] + [Creates a service object and adds it to the execution_context. ] + ] + + [ [[link asio.reference.execution_context.use_service [*use_service]]] [Obtain the service object corresponding to the given type. ] ] @@ -58759,7 +61526,7 @@ [section:add_service execution_context::add_service] [indexterm2 add_service..execution_context] -Add a service object to the [link asio.reference.execution_context `execution_context`]. +(Deprecated: Use `make_service()`.) Add a service object to the [link asio.reference.execution_context `execution_context`]. template< @@ -58927,6 +61694,57 @@ +[section:make_service execution_context::make_service] + +[indexterm2 make_service..execution_context] +Creates a service object and adds it to the [link asio.reference.execution_context `execution_context`]. + + + template< + typename ``[link asio.reference.Service Service]``, + typename... Args> + friend Service & make_service( + execution_context & e, + Args &&... args); + + +This function is used to add a service to the [link asio.reference.execution_context `execution_context`]. + + +[heading Parameters] + + +[variablelist + +[[e][The [link asio.reference.execution_context `execution_context`] object that owns the service.]] + +[[args][Zero or more arguments to be passed to the service constructor.]] + +] + + +[heading Exceptions] + + +[variablelist + +[[asio::service_already_exists][Thrown if a service of the given type is already present in the [link asio.reference.execution_context `execution_context`]. ]] + +] + + + +[heading Requirements] + +['Header: ][^asio/execution_context.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + [section:notify_fork execution_context::notify_fork] [indexterm2 notify_fork..execution_context] @@ -59028,7 +61846,7 @@ template< typename ``[link asio.reference.Service Service]``> friend Service & ``[link asio.reference.execution_context.use_service.overload2 use_service]``( - io_service & i); + io_service & ios); `` [''''»''' [link asio.reference.execution_context.use_service.overload2 more...]]`` @@ -59083,7 +61901,7 @@ template< typename ``[link asio.reference.Service Service]``> friend Service & use_service( - io_service & i); + io_service & ios); This function is used to locate a service object that corresponds to the given service type. If there is no existing implementation of the service, then the [link asio.reference.io_service `io_service`] will create a new instance of the service. @@ -59094,7 +61912,7 @@ [variablelist -[[i][The [link asio.reference.io_service `io_service`] object that owns the service.]] +[[ios][The [link asio.reference.io_service `io_service`] object that owns the service.]] ] @@ -59494,7 +62312,7 @@ typename Function, typename Allocator> void defer( - Function f, + Function && f, const Allocator & a); @@ -59533,7 +62351,7 @@ typename Function, typename Allocator> void dispatch( - Function f, + Function && f, const Allocator & a); @@ -59810,7 +62628,7 @@ template< typename ``[link asio.reference.Executor Executor]``> executor & ``[link asio.reference.executor.operator_eq_.overload4 operator=]``( - Executor e); + Executor && e); `` [''''»''' [link asio.reference.executor.operator_eq_.overload4 more...]]`` @@ -59866,7 +62684,7 @@ template< typename ``[link asio.reference.Executor Executor]``> executor & operator=( - Executor e); + Executor && e); @@ -59908,7 +62726,7 @@ typename Function, typename Allocator> void post( - Function f, + Function && f, const Allocator & a); @@ -60554,7 +63372,7 @@ ``[link asio.reference.executor_wrapper.executor_wrapper.overload1 executor_wrapper]``( executor_arg_t , const executor_type & e, - U u); + U && u); `` [''''»''' [link asio.reference.executor_wrapper.executor_wrapper.overload1 more...]]`` @@ -60653,7 +63471,7 @@ executor_wrapper( executor_arg_t , const executor_type & e, - U u); + U && u); This constructor is only valid if the type `T` is constructible from type `U`. @@ -65683,7 +68501,7 @@ [ [[link asio.reference.io_service__work [*work]]] - [Class to inform the io_service when it has work to do. ] + [(Deprecated: Use executor_work.) Class to inform the io_service when it has work to do. ] ] @@ -65799,7 +68617,7 @@ [ [[link asio.reference.io_service.add_service [*add_service]]] - [Add a service object to the execution_context. ] + [(Deprecated: Use make_service().) Add a service object to the execution_context. ] ] [ @@ -65808,6 +68626,11 @@ ] [ + [[link asio.reference.io_service.make_service [*make_service]]] + [Creates a service object and adds it to the execution_context. ] + ] + + [ [[link asio.reference.io_service.use_service [*use_service]]] [ @@ -65919,7 +68742,7 @@ ['Inherited from execution_context.] [indexterm2 add_service..io_service] -Add a service object to the [link asio.reference.execution_context `execution_context`]. +(Deprecated: Use `make_service()`.) Add a service object to the [link asio.reference.execution_context `execution_context`]. template< @@ -66005,7 +68828,7 @@ template< typename ``[link asio.reference.CompletionHandler CompletionHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` dispatch( - CompletionHandler handler); + CompletionHandler && handler); This function is used to ask the [link asio.reference.io_service `io_service`] to execute the given handler. @@ -66202,6 +69025,60 @@ [endsect] +[section:make_service io_service::make_service] + + +['Inherited from execution_context.] + +[indexterm2 make_service..io_service] +Creates a service object and adds it to the [link asio.reference.execution_context `execution_context`]. + + + template< + typename ``[link asio.reference.Service Service]``, + typename... Args> + friend Service & make_service( + execution_context & e, + Args &&... args); + + +This function is used to add a service to the [link asio.reference.execution_context `execution_context`]. + + +[heading Parameters] + + +[variablelist + +[[e][The [link asio.reference.execution_context `execution_context`] object that owns the service.]] + +[[args][Zero or more arguments to be passed to the service constructor.]] + +] + + +[heading Exceptions] + + +[variablelist + +[[asio::service_already_exists][Thrown if a service of the given type is already present in the [link asio.reference.execution_context `execution_context`]. ]] + +] + + + +[heading Requirements] + +['Header: ][^asio/io_service.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + [section:notify_fork io_service::notify_fork] @@ -66444,7 +69321,7 @@ template< typename ``[link asio.reference.CompletionHandler CompletionHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` post( - CompletionHandler handler); + CompletionHandler && handler); This function is used to ask the [link asio.reference.io_service `io_service`] to execute the given handler, but without allowing the [link asio.reference.io_service `io_service`] to call the handler from inside this function. @@ -66794,7 +69671,7 @@ [variablelist -[[i][The [link asio.reference.io_service `io_service`] object that owns the service.]] +[[ios][The [link asio.reference.io_service `io_service`] object that owns the service.]] ] @@ -67065,7 +69942,7 @@ typename Function, typename Allocator> void defer( - Function f, + Function && f, const Allocator & a); @@ -67106,7 +69983,7 @@ typename Function, typename Allocator> void dispatch( - Function f, + Function && f, const Allocator & a); @@ -67225,7 +70102,7 @@ typename Function, typename Allocator> void post( - Function f, + Function && f, const Allocator & a); @@ -67559,7 +70436,7 @@ typename Function, typename Allocator> void defer( - Function f, + Function && f, const Allocator & a); @@ -67597,7 +70474,7 @@ typename Function, typename Allocator> void ``[link asio.reference.io_service__strand.dispatch.overload1 dispatch]``( - Function f, + Function && f, const Allocator & a); `` [''''»''' [link asio.reference.io_service__strand.dispatch.overload1 more...]]`` @@ -67608,7 +70485,7 @@ template< typename ``[link asio.reference.CompletionHandler CompletionHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.io_service__strand.dispatch.overload2 dispatch]``( - CompletionHandler handler); + CompletionHandler && handler); `` [''''»''' [link asio.reference.io_service__strand.dispatch.overload2 more...]]`` @@ -67622,7 +70499,7 @@ typename Function, typename Allocator> void dispatch( - Function f, + Function && f, const Allocator & a); @@ -67660,7 +70537,7 @@ template< typename ``[link asio.reference.CompletionHandler CompletionHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` dispatch( - CompletionHandler handler); + CompletionHandler && handler); This function is used to ask the strand to execute the given handler. @@ -67804,7 +70681,7 @@ typename Function, typename Allocator> void ``[link asio.reference.io_service__strand.post.overload1 post]``( - Function f, + Function && f, const Allocator & a); `` [''''»''' [link asio.reference.io_service__strand.post.overload1 more...]]`` @@ -67815,7 +70692,7 @@ template< typename ``[link asio.reference.CompletionHandler CompletionHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.io_service__strand.post.overload2 post]``( - CompletionHandler handler); + CompletionHandler && handler); `` [''''»''' [link asio.reference.io_service__strand.post.overload2 more...]]`` @@ -67829,7 +70706,7 @@ typename Function, typename Allocator> void post( - Function f, + Function && f, const Allocator & a); @@ -67867,7 +70744,7 @@ template< typename ``[link asio.reference.CompletionHandler CompletionHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` post( - CompletionHandler handler); + CompletionHandler && handler); This function is used to ask the strand to execute the given handler, but without allowing the strand to call the handler from inside this function. @@ -68030,7 +70907,7 @@ [section:io_service__work io_service::work] -Class to inform the [link asio.reference.io_service `io_service`] when it has work to do. +(Deprecated: Use [link asio.reference.executor_work `executor_work`].) Class to inform the [link asio.reference.io_service `io_service`] when it has work to do. class work @@ -69228,6 +72105,2467 @@ [endsect] +[section:ip__address_iterator_v4 ip::address_iterator_v4] + + +An input iterator that can be used for traversing IPv4 addresses. + + + class address_iterator_v4 + + +[heading Types] +[table + [[Name][Description]] + + [ + + [[link asio.reference.ip__address_iterator_v4.difference_type [*difference_type]]] + [Distance between two iterators. ] + + ] + + [ + + [[link asio.reference.ip__address_iterator_v4.iterator_category [*iterator_category]]] + [Denotes that the iterator satisfies the input iterator requirements. ] + + ] + + [ + + [[link asio.reference.ip__address_iterator_v4.pointer [*pointer]]] + [The type of a pointer to an element pointed to by the iterator. ] + + ] + + [ + + [[link asio.reference.ip__address_iterator_v4.reference [*reference]]] + [The type of a reference to an element pointed to by the iterator. ] + + ] + + [ + + [[link asio.reference.ip__address_iterator_v4.value_type [*value_type]]] + [The type of the elements pointed to by the iterator. ] + + ] + +] + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_iterator_v4.address_iterator_v4 [*address_iterator_v4]]] + [Construct an iterator that points to the specified address. + + Copy constructor. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v4.operator__star_ [*operator *]]] + [Dereference the iterator. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v4.operator_plus__plus_ [*operator++]]] + [Pre-increment operator. + + Post-increment operator. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v4.operator_minus__minus_ [*operator--]]] + [Pre-decrement operator. + + Post-decrement operator. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v4.operator_arrow_ [*operator->]]] + [Dereference the iterator. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v4.operator_eq_ [*operator=]]] + [Assignment operator. ] + ] + +] + +[heading Friends] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_iterator_v4.operator_not__eq_ [*operator!=]]] + [Compare two addresses for inequality. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v4.operator_eq__eq_ [*operator==]]] + [Compare two addresses for equality. ] + ] + +] + +In addition to satisfying the input iterator requirements, this iterator also supports decrement. + + +[heading Thread Safety] + +['Distinct] ['objects:] Safe. + +['Shared] ['objects:] Unsafe. + + + +[heading Requirements] + +['Header: ][^asio/ip/address_iterator_v4.hpp] + +['Convenience header: ][^asio.hpp] + +[section:address_iterator_v4 ip::address_iterator_v4::address_iterator_v4] + +[indexterm2 address_iterator_v4..ip::address_iterator_v4] +Construct an iterator that points to the specified address. + + + ``[link asio.reference.ip__address_iterator_v4.address_iterator_v4.overload1 address_iterator_v4]``( + const address_v4 & addr); + `` [''''»''' [link asio.reference.ip__address_iterator_v4.address_iterator_v4.overload1 more...]]`` + + +Copy constructor. + + + ``[link asio.reference.ip__address_iterator_v4.address_iterator_v4.overload2 address_iterator_v4]``( + const address_iterator_v4 & other); + `` [''''»''' [link asio.reference.ip__address_iterator_v4.address_iterator_v4.overload2 more...]]`` + + +[section:overload1 ip::address_iterator_v4::address_iterator_v4 (1 of 2 overloads)] + + +Construct an iterator that points to the specified address. + + + address_iterator_v4( + const address_v4 & addr); + + + +[endsect] + + + +[section:overload2 ip::address_iterator_v4::address_iterator_v4 (2 of 2 overloads)] + + +Copy constructor. + + + address_iterator_v4( + const address_iterator_v4 & other); + + + +[endsect] + + +[endsect] + + +[section:difference_type ip::address_iterator_v4::difference_type] + +[indexterm2 difference_type..ip::address_iterator_v4] +Distance between two iterators. + + + typedef std::ptrdiff_t difference_type; + + + +[heading Requirements] + +['Header: ][^asio/ip/address_iterator_v4.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:iterator_category ip::address_iterator_v4::iterator_category] + +[indexterm2 iterator_category..ip::address_iterator_v4] +Denotes that the iterator satisfies the input iterator requirements. + + + typedef std::input_iterator_tag iterator_category; + + + +[heading Requirements] + +['Header: ][^asio/ip/address_iterator_v4.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:operator__star_ ip::address_iterator_v4::operator *] + +[indexterm2 operator *..ip::address_iterator_v4] +Dereference the iterator. + + + const address_v4 & operator *() const; + + + +[endsect] + + + +[section:operator_not__eq_ ip::address_iterator_v4::operator!=] + +[indexterm2 operator!=..ip::address_iterator_v4] +Compare two addresses for inequality. + + + friend bool operator!=( + const address_iterator_v4 & a, + const address_iterator_v4 & b); + + +[heading Requirements] + +['Header: ][^asio/ip/address_iterator_v4.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + +[section:operator_plus__plus_ ip::address_iterator_v4::operator++] + +[indexterm2 operator++..ip::address_iterator_v4] +Pre-increment operator. + + + address_iterator_v4 & ``[link asio.reference.ip__address_iterator_v4.operator_plus__plus_.overload1 operator++]``(); + `` [''''»''' [link asio.reference.ip__address_iterator_v4.operator_plus__plus_.overload1 more...]]`` + + +Post-increment operator. + + + address_iterator_v4 ``[link asio.reference.ip__address_iterator_v4.operator_plus__plus_.overload2 operator++]``( + int ); + `` [''''»''' [link asio.reference.ip__address_iterator_v4.operator_plus__plus_.overload2 more...]]`` + + +[section:overload1 ip::address_iterator_v4::operator++ (1 of 2 overloads)] + + +Pre-increment operator. + + + address_iterator_v4 & operator++(); + + + +[endsect] + + + +[section:overload2 ip::address_iterator_v4::operator++ (2 of 2 overloads)] + + +Post-increment operator. + + + address_iterator_v4 operator++( + int ); + + + +[endsect] + + +[endsect] + +[section:operator_minus__minus_ ip::address_iterator_v4::operator--] + +[indexterm2 operator--..ip::address_iterator_v4] +Pre-decrement operator. + + + address_iterator_v4 & ``[link asio.reference.ip__address_iterator_v4.operator_minus__minus_.overload1 operator--]``(); + `` [''''»''' [link asio.reference.ip__address_iterator_v4.operator_minus__minus_.overload1 more...]]`` + + +Post-decrement operator. + + + address_iterator_v4 ``[link asio.reference.ip__address_iterator_v4.operator_minus__minus_.overload2 operator--]``( + int ); + `` [''''»''' [link asio.reference.ip__address_iterator_v4.operator_minus__minus_.overload2 more...]]`` + + +[section:overload1 ip::address_iterator_v4::operator-- (1 of 2 overloads)] + + +Pre-decrement operator. + + + address_iterator_v4 & operator--(); + + + +[endsect] + + + +[section:overload2 ip::address_iterator_v4::operator-- (2 of 2 overloads)] + + +Post-decrement operator. + + + address_iterator_v4 operator--( + int ); + + + +[endsect] + + +[endsect] + + +[section:operator_arrow_ ip::address_iterator_v4::operator->] + +[indexterm2 operator->..ip::address_iterator_v4] +Dereference the iterator. + + + const address_v4 * operator->() const; + + + +[endsect] + + + +[section:operator_eq_ ip::address_iterator_v4::operator=] + +[indexterm2 operator=..ip::address_iterator_v4] +Assignment operator. + + + address_iterator_v4 & operator=( + const address_iterator_v4 & other); + + + +[endsect] + + + +[section:operator_eq__eq_ ip::address_iterator_v4::operator==] + +[indexterm2 operator==..ip::address_iterator_v4] +Compare two addresses for equality. + + + friend bool operator==( + const address_iterator_v4 & a, + const address_iterator_v4 & b); + + +[heading Requirements] + +['Header: ][^asio/ip/address_iterator_v4.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:pointer ip::address_iterator_v4::pointer] + +[indexterm2 pointer..ip::address_iterator_v4] +The type of a pointer to an element pointed to by the iterator. + + + typedef const address_v4 * pointer; + + + +[heading Requirements] + +['Header: ][^asio/ip/address_iterator_v4.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:reference ip::address_iterator_v4::reference] + +[indexterm2 reference..ip::address_iterator_v4] +The type of a reference to an element pointed to by the iterator. + + + typedef const address_v4 & reference; + + +[heading Types] +[table + [[Name][Description]] + + [ + + [[link asio.reference.ip__address_v4.bytes_type [*bytes_type]]] + [The type used to represent an address as an array of bytes. ] + + ] + +] + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_v4.address_v4 [*address_v4]]] + [Default constructor. + + Construct an address from raw bytes. + + Construct an address from an unsigned long in host byte order. + + Copy constructor. ] + ] + + [ + [[link asio.reference.ip__address_v4.any [*any]]] + [Obtain an address object that represents any address. ] + ] + + [ + [[link asio.reference.ip__address_v4.broadcast [*broadcast]]] + [Obtain an address object that represents the broadcast address. + + Obtain an address object that represents the broadcast address that corresponds to the specified address and netmask. ] + ] + + [ + [[link asio.reference.ip__address_v4.from_string [*from_string]]] + [(Deprecated: Use make_address_v4().) Create an address from an IP address string in dotted decimal form. ] + ] + + [ + [[link asio.reference.ip__address_v4.is_class_a [*is_class_a]]] + [Determine whether the address is a class A address. ] + ] + + [ + [[link asio.reference.ip__address_v4.is_class_b [*is_class_b]]] + [Determine whether the address is a class B address. ] + ] + + [ + [[link asio.reference.ip__address_v4.is_class_c [*is_class_c]]] + [Determine whether the address is a class C address. ] + ] + + [ + [[link asio.reference.ip__address_v4.is_loopback [*is_loopback]]] + [Determine whether the address is a loopback address. ] + ] + + [ + [[link asio.reference.ip__address_v4.is_multicast [*is_multicast]]] + [Determine whether the address is a multicast address. ] + ] + + [ + [[link asio.reference.ip__address_v4.is_unspecified [*is_unspecified]]] + [Determine whether the address is unspecified. ] + ] + + [ + [[link asio.reference.ip__address_v4.loopback [*loopback]]] + [Obtain an address object that represents the loopback address. ] + ] + + [ + [[link asio.reference.ip__address_v4.netmask [*netmask]]] + [Obtain the netmask that corresponds to the address, based on its address class. ] + ] + + [ + [[link asio.reference.ip__address_v4.operator_eq_ [*operator=]]] + [Assign from another address. ] + ] + + [ + [[link asio.reference.ip__address_v4.to_bytes [*to_bytes]]] + [Get the address in bytes, in network byte order. ] + ] + + [ + [[link asio.reference.ip__address_v4.to_string [*to_string]]] + [Get the address as a string in dotted decimal format. ] + ] + + [ + [[link asio.reference.ip__address_v4.to_ulong [*to_ulong]]] + [Get the address as an unsigned long in host byte order. ] + ] + +] + +[heading Friends] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_v4.operator_not__eq_ [*operator!=]]] + [Compare two addresses for inequality. ] + ] + + [ + [[link asio.reference.ip__address_v4.operator_lt_ [*operator<]]] + [Compare addresses for ordering. ] + ] + + [ + [[link asio.reference.ip__address_v4.operator_lt__eq_ [*operator<=]]] + [Compare addresses for ordering. ] + ] + + [ + [[link asio.reference.ip__address_v4.operator_eq__eq_ [*operator==]]] + [Compare two addresses for equality. ] + ] + + [ + [[link asio.reference.ip__address_v4.operator_gt_ [*operator>]]] + [Compare addresses for ordering. ] + ] + + [ + [[link asio.reference.ip__address_v4.operator_gt__eq_ [*operator>=]]] + [Compare addresses for ordering. ] + ] + +] + +[heading Related Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_v4.make_address_v4 [*make_address_v4]]] + [Create an IPv4 address from raw bytes in network order. + + Create an IPv4 address from an unsigned long in host byte order. + + Create an IPv4 address from an IP address string in dotted decimal form. + + Create an IPv4 address from a IPv4-mapped IPv6 address. ] + ] + + [ + [[link asio.reference.ip__address_v4.make_network_v4 [*make_network_v4]]] + [Create an IPv4 network from an address and prefix length. + + Create an IPv4 network from an address and netmask. ] + ] + + [ + [[link asio.reference.ip__address_v4.operator_lt__lt_ [*operator<<]]] + [Output an address as a string. + + Output a network as a string. ] + ] + +] + +The [link asio.reference.ip__address_v4 `ip::address_v4`] class provides the ability to use and manipulate IP version 4 addresses. + + +[heading Thread Safety] + +['Distinct] ['objects:] Safe. + +['Shared] ['objects:] Unsafe. + + + + +[heading Requirements] + +['Header: ][^asio/ip/address_iterator_v4.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:value_type ip::address_iterator_v4::value_type] + +[indexterm2 value_type..ip::address_iterator_v4] +The type of the elements pointed to by the iterator. + + + typedef address_v4 value_type; + + +[heading Types] +[table + [[Name][Description]] + + [ + + [[link asio.reference.ip__address_v4.bytes_type [*bytes_type]]] + [The type used to represent an address as an array of bytes. ] + + ] + +] + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_v4.address_v4 [*address_v4]]] + [Default constructor. + + Construct an address from raw bytes. + + Construct an address from an unsigned long in host byte order. + + Copy constructor. ] + ] + + [ + [[link asio.reference.ip__address_v4.any [*any]]] + [Obtain an address object that represents any address. ] + ] + + [ + [[link asio.reference.ip__address_v4.broadcast [*broadcast]]] + [Obtain an address object that represents the broadcast address. + + Obtain an address object that represents the broadcast address that corresponds to the specified address and netmask. ] + ] + + [ + [[link asio.reference.ip__address_v4.from_string [*from_string]]] + [(Deprecated: Use make_address_v4().) Create an address from an IP address string in dotted decimal form. ] + ] + + [ + [[link asio.reference.ip__address_v4.is_class_a [*is_class_a]]] + [Determine whether the address is a class A address. ] + ] + + [ + [[link asio.reference.ip__address_v4.is_class_b [*is_class_b]]] + [Determine whether the address is a class B address. ] + ] + + [ + [[link asio.reference.ip__address_v4.is_class_c [*is_class_c]]] + [Determine whether the address is a class C address. ] + ] + + [ + [[link asio.reference.ip__address_v4.is_loopback [*is_loopback]]] + [Determine whether the address is a loopback address. ] + ] + + [ + [[link asio.reference.ip__address_v4.is_multicast [*is_multicast]]] + [Determine whether the address is a multicast address. ] + ] + + [ + [[link asio.reference.ip__address_v4.is_unspecified [*is_unspecified]]] + [Determine whether the address is unspecified. ] + ] + + [ + [[link asio.reference.ip__address_v4.loopback [*loopback]]] + [Obtain an address object that represents the loopback address. ] + ] + + [ + [[link asio.reference.ip__address_v4.netmask [*netmask]]] + [Obtain the netmask that corresponds to the address, based on its address class. ] + ] + + [ + [[link asio.reference.ip__address_v4.operator_eq_ [*operator=]]] + [Assign from another address. ] + ] + + [ + [[link asio.reference.ip__address_v4.to_bytes [*to_bytes]]] + [Get the address in bytes, in network byte order. ] + ] + + [ + [[link asio.reference.ip__address_v4.to_string [*to_string]]] + [Get the address as a string in dotted decimal format. ] + ] + + [ + [[link asio.reference.ip__address_v4.to_ulong [*to_ulong]]] + [Get the address as an unsigned long in host byte order. ] + ] + +] + +[heading Friends] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_v4.operator_not__eq_ [*operator!=]]] + [Compare two addresses for inequality. ] + ] + + [ + [[link asio.reference.ip__address_v4.operator_lt_ [*operator<]]] + [Compare addresses for ordering. ] + ] + + [ + [[link asio.reference.ip__address_v4.operator_lt__eq_ [*operator<=]]] + [Compare addresses for ordering. ] + ] + + [ + [[link asio.reference.ip__address_v4.operator_eq__eq_ [*operator==]]] + [Compare two addresses for equality. ] + ] + + [ + [[link asio.reference.ip__address_v4.operator_gt_ [*operator>]]] + [Compare addresses for ordering. ] + ] + + [ + [[link asio.reference.ip__address_v4.operator_gt__eq_ [*operator>=]]] + [Compare addresses for ordering. ] + ] + +] + +[heading Related Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_v4.make_address_v4 [*make_address_v4]]] + [Create an IPv4 address from raw bytes in network order. + + Create an IPv4 address from an unsigned long in host byte order. + + Create an IPv4 address from an IP address string in dotted decimal form. + + Create an IPv4 address from a IPv4-mapped IPv6 address. ] + ] + + [ + [[link asio.reference.ip__address_v4.make_network_v4 [*make_network_v4]]] + [Create an IPv4 network from an address and prefix length. + + Create an IPv4 network from an address and netmask. ] + ] + + [ + [[link asio.reference.ip__address_v4.operator_lt__lt_ [*operator<<]]] + [Output an address as a string. + + Output a network as a string. ] + ] + +] + +The [link asio.reference.ip__address_v4 `ip::address_v4`] class provides the ability to use and manipulate IP version 4 addresses. + + +[heading Thread Safety] + +['Distinct] ['objects:] Safe. + +['Shared] ['objects:] Unsafe. + + + + +[heading Requirements] + +['Header: ][^asio/ip/address_iterator_v4.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[endsect] + +[section:ip__address_iterator_v6 ip::address_iterator_v6] + + +An input iterator that can be used for traversing IPv6 addresses. + + + class address_iterator_v6 + + +[heading Types] +[table + [[Name][Description]] + + [ + + [[link asio.reference.ip__address_iterator_v6.difference_type [*difference_type]]] + [Distance between two iterators. ] + + ] + + [ + + [[link asio.reference.ip__address_iterator_v6.iterator_category [*iterator_category]]] + [Denotes that the iterator satisfies the input iterator requirements. ] + + ] + + [ + + [[link asio.reference.ip__address_iterator_v6.pointer [*pointer]]] + [The type of a pointer to an element pointed to by the iterator. ] + + ] + + [ + + [[link asio.reference.ip__address_iterator_v6.reference [*reference]]] + [The type of a reference to an element pointed to by the iterator. ] + + ] + + [ + + [[link asio.reference.ip__address_iterator_v6.value_type [*value_type]]] + [The type of the elements pointed to by the iterator. ] + + ] + +] + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_iterator_v6.address_iterator_v6 [*address_iterator_v6]]] + [Construct an iterator that points to the specified address. + + Copy constructor. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v6.operator__star_ [*operator *]]] + [Dereference the iterator. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v6.operator_plus__plus_ [*operator++]]] + [Pre-increment operator. + + Post-increment operator. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v6.operator_minus__minus_ [*operator--]]] + [Pre-decrement operator. + + Post-decrement operator. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v6.operator_arrow_ [*operator->]]] + [Dereference the iterator. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v6.operator_eq_ [*operator=]]] + [Assignment operator. ] + ] + +] + +[heading Friends] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_iterator_v6.operator_not__eq_ [*operator!=]]] + [Compare two addresses for inequality. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v6.operator_eq__eq_ [*operator==]]] + [Compare two addresses for equality. ] + ] + +] + +In addition to satisfying the input iterator requirements, this iterator also supports decrement. + + +[heading Thread Safety] + +['Distinct] ['objects:] Safe. + +['Shared] ['objects:] Unsafe. + + + +[heading Requirements] + +['Header: ][^asio/ip/address_iterator_v6.hpp] + +['Convenience header: ][^asio.hpp] + +[section:address_iterator_v6 ip::address_iterator_v6::address_iterator_v6] + +[indexterm2 address_iterator_v6..ip::address_iterator_v6] +Construct an iterator that points to the specified address. + + + ``[link asio.reference.ip__address_iterator_v6.address_iterator_v6.overload1 address_iterator_v6]``( + const address_v6 & addr); + `` [''''»''' [link asio.reference.ip__address_iterator_v6.address_iterator_v6.overload1 more...]]`` + + +Copy constructor. + + + ``[link asio.reference.ip__address_iterator_v6.address_iterator_v6.overload2 address_iterator_v6]``( + const address_iterator_v6 & other); + `` [''''»''' [link asio.reference.ip__address_iterator_v6.address_iterator_v6.overload2 more...]]`` + + +[section:overload1 ip::address_iterator_v6::address_iterator_v6 (1 of 2 overloads)] + + +Construct an iterator that points to the specified address. + + + address_iterator_v6( + const address_v6 & addr); + + + +[endsect] + + + +[section:overload2 ip::address_iterator_v6::address_iterator_v6 (2 of 2 overloads)] + + +Copy constructor. + + + address_iterator_v6( + const address_iterator_v6 & other); + + + +[endsect] + + +[endsect] + + +[section:difference_type ip::address_iterator_v6::difference_type] + +[indexterm2 difference_type..ip::address_iterator_v6] +Distance between two iterators. + + + typedef std::ptrdiff_t difference_type; + + + +[heading Requirements] + +['Header: ][^asio/ip/address_iterator_v6.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:iterator_category ip::address_iterator_v6::iterator_category] + +[indexterm2 iterator_category..ip::address_iterator_v6] +Denotes that the iterator satisfies the input iterator requirements. + + + typedef std::input_iterator_tag iterator_category; + + + +[heading Requirements] + +['Header: ][^asio/ip/address_iterator_v6.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:operator__star_ ip::address_iterator_v6::operator *] + +[indexterm2 operator *..ip::address_iterator_v6] +Dereference the iterator. + + + const address_v6 & operator *() const; + + + +[endsect] + + + +[section:operator_not__eq_ ip::address_iterator_v6::operator!=] + +[indexterm2 operator!=..ip::address_iterator_v6] +Compare two addresses for inequality. + + + friend bool operator!=( + const address_iterator_v6 & a, + const address_iterator_v6 & b); + + +[heading Requirements] + +['Header: ][^asio/ip/address_iterator_v6.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + +[section:operator_plus__plus_ ip::address_iterator_v6::operator++] + +[indexterm2 operator++..ip::address_iterator_v6] +Pre-increment operator. + + + address_iterator_v6 & ``[link asio.reference.ip__address_iterator_v6.operator_plus__plus_.overload1 operator++]``(); + `` [''''»''' [link asio.reference.ip__address_iterator_v6.operator_plus__plus_.overload1 more...]]`` + + +Post-increment operator. + + + address_iterator_v6 ``[link asio.reference.ip__address_iterator_v6.operator_plus__plus_.overload2 operator++]``( + int ); + `` [''''»''' [link asio.reference.ip__address_iterator_v6.operator_plus__plus_.overload2 more...]]`` + + +[section:overload1 ip::address_iterator_v6::operator++ (1 of 2 overloads)] + + +Pre-increment operator. + + + address_iterator_v6 & operator++(); + + + +[endsect] + + + +[section:overload2 ip::address_iterator_v6::operator++ (2 of 2 overloads)] + + +Post-increment operator. + + + address_iterator_v6 operator++( + int ); + + + +[endsect] + + +[endsect] + +[section:operator_minus__minus_ ip::address_iterator_v6::operator--] + +[indexterm2 operator--..ip::address_iterator_v6] +Pre-decrement operator. + + + address_iterator_v6 & ``[link asio.reference.ip__address_iterator_v6.operator_minus__minus_.overload1 operator--]``(); + `` [''''»''' [link asio.reference.ip__address_iterator_v6.operator_minus__minus_.overload1 more...]]`` + + +Post-decrement operator. + + + address_iterator_v6 ``[link asio.reference.ip__address_iterator_v6.operator_minus__minus_.overload2 operator--]``( + int ); + `` [''''»''' [link asio.reference.ip__address_iterator_v6.operator_minus__minus_.overload2 more...]]`` + + +[section:overload1 ip::address_iterator_v6::operator-- (1 of 2 overloads)] + + +Pre-decrement operator. + + + address_iterator_v6 & operator--(); + + + +[endsect] + + + +[section:overload2 ip::address_iterator_v6::operator-- (2 of 2 overloads)] + + +Post-decrement operator. + + + address_iterator_v6 operator--( + int ); + + + +[endsect] + + +[endsect] + + +[section:operator_arrow_ ip::address_iterator_v6::operator->] + +[indexterm2 operator->..ip::address_iterator_v6] +Dereference the iterator. + + + const address_v6 * operator->() const; + + + +[endsect] + + + +[section:operator_eq_ ip::address_iterator_v6::operator=] + +[indexterm2 operator=..ip::address_iterator_v6] +Assignment operator. + + + address_iterator_v6 & operator=( + const address_iterator_v6 & other); + + + +[endsect] + + + +[section:operator_eq__eq_ ip::address_iterator_v6::operator==] + +[indexterm2 operator==..ip::address_iterator_v6] +Compare two addresses for equality. + + + friend bool operator==( + const address_iterator_v6 & a, + const address_iterator_v6 & b); + + +[heading Requirements] + +['Header: ][^asio/ip/address_iterator_v6.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:pointer ip::address_iterator_v6::pointer] + +[indexterm2 pointer..ip::address_iterator_v6] +The type of a pointer to an element pointed to by the iterator. + + + typedef const address_v6 * pointer; + + + +[heading Requirements] + +['Header: ][^asio/ip/address_iterator_v6.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:reference ip::address_iterator_v6::reference] + +[indexterm2 reference..ip::address_iterator_v6] +The type of a reference to an element pointed to by the iterator. + + + typedef const address_v6 & reference; + + +[heading Types] +[table + [[Name][Description]] + + [ + + [[link asio.reference.ip__address_v6.bytes_type [*bytes_type]]] + [The type used to represent an address as an array of bytes. ] + + ] + +] + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_v6.address_v6 [*address_v6]]] + [Default constructor. + + Construct an address from raw bytes and scope ID. + + Copy constructor. ] + ] + + [ + [[link asio.reference.ip__address_v6.any [*any]]] + [Obtain an address object that represents any address. ] + ] + + [ + [[link asio.reference.ip__address_v6.from_string [*from_string]]] + [(Deprecated: Use make_address_v6().) Create an IPv6 address from an IP address string. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_link_local [*is_link_local]]] + [Determine whether the address is link local. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_loopback [*is_loopback]]] + [Determine whether the address is a loopback address. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_multicast [*is_multicast]]] + [Determine whether the address is a multicast address. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_multicast_global [*is_multicast_global]]] + [Determine whether the address is a global multicast address. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_multicast_link_local [*is_multicast_link_local]]] + [Determine whether the address is a link-local multicast address. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_multicast_node_local [*is_multicast_node_local]]] + [Determine whether the address is a node-local multicast address. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_multicast_org_local [*is_multicast_org_local]]] + [Determine whether the address is a org-local multicast address. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_multicast_site_local [*is_multicast_site_local]]] + [Determine whether the address is a site-local multicast address. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_site_local [*is_site_local]]] + [Determine whether the address is site local. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_unspecified [*is_unspecified]]] + [Determine whether the address is unspecified. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_v4_compatible [*is_v4_compatible]]] + [(Deprecated: No replacement.) Determine whether the address is an IPv4-compatible address. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_v4_mapped [*is_v4_mapped]]] + [Determine whether the address is a mapped IPv4 address. ] + ] + + [ + [[link asio.reference.ip__address_v6.loopback [*loopback]]] + [Obtain an address object that represents the loopback address. ] + ] + + [ + [[link asio.reference.ip__address_v6.operator_eq_ [*operator=]]] + [Assign from another address. ] + ] + + [ + [[link asio.reference.ip__address_v6.scope_id [*scope_id]]] + [The scope ID of the address. ] + ] + + [ + [[link asio.reference.ip__address_v6.to_bytes [*to_bytes]]] + [Get the address in bytes, in network byte order. ] + ] + + [ + [[link asio.reference.ip__address_v6.to_string [*to_string]]] + [Get the address as a string. ] + ] + + [ + [[link asio.reference.ip__address_v6.to_v4 [*to_v4]]] + [(Deprecated: Use make_address_v4().) Converts an IPv4-mapped or IPv4-compatible address to an IPv4 address. ] + ] + + [ + [[link asio.reference.ip__address_v6.v4_compatible [*v4_compatible]]] + [(Deprecated: No replacement.) Create an IPv4-compatible IPv6 address. ] + ] + + [ + [[link asio.reference.ip__address_v6.v4_mapped [*v4_mapped]]] + [(Deprecated: Use make_address_v6().) Create an IPv4-mapped IPv6 address. ] + ] + +] + +[heading Friends] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_v6.operator_not__eq_ [*operator!=]]] + [Compare two addresses for inequality. ] + ] + + [ + [[link asio.reference.ip__address_v6.operator_lt_ [*operator<]]] + [Compare addresses for ordering. ] + ] + + [ + [[link asio.reference.ip__address_v6.operator_lt__eq_ [*operator<=]]] + [Compare addresses for ordering. ] + ] + + [ + [[link asio.reference.ip__address_v6.operator_eq__eq_ [*operator==]]] + [Compare two addresses for equality. ] + ] + + [ + [[link asio.reference.ip__address_v6.operator_gt_ [*operator>]]] + [Compare addresses for ordering. ] + ] + + [ + [[link asio.reference.ip__address_v6.operator_gt__eq_ [*operator>=]]] + [Compare addresses for ordering. ] + ] + +] + +[heading Related Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_v6.make_address_v6 [*make_address_v6]]] + [Create an IPv6 address from raw bytes and scope ID. + + Create an IPv6 address from an IP address string. + + Createan IPv6 address from an IP address string. + + Create an IPv4-mapped IPv6 address from an IPv4 address. ] + ] + + [ + [[link asio.reference.ip__address_v6.make_network_v6 [*make_network_v6]]] + [Create an IPv6 network from an address and prefix length. ] + ] + + [ + [[link asio.reference.ip__address_v6.operator_lt__lt_ [*operator<<]]] + [Output an address as a string. + + Output a network as a string. ] + ] + +] + +The [link asio.reference.ip__address_v6 `ip::address_v6`] class provides the ability to use and manipulate IP version 6 addresses. + + +[heading Thread Safety] + +['Distinct] ['objects:] Safe. + +['Shared] ['objects:] Unsafe. + + + + +[heading Requirements] + +['Header: ][^asio/ip/address_iterator_v6.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:value_type ip::address_iterator_v6::value_type] + +[indexterm2 value_type..ip::address_iterator_v6] +The type of the elements pointed to by the iterator. + + + typedef address_v6 value_type; + + +[heading Types] +[table + [[Name][Description]] + + [ + + [[link asio.reference.ip__address_v6.bytes_type [*bytes_type]]] + [The type used to represent an address as an array of bytes. ] + + ] + +] + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_v6.address_v6 [*address_v6]]] + [Default constructor. + + Construct an address from raw bytes and scope ID. + + Copy constructor. ] + ] + + [ + [[link asio.reference.ip__address_v6.any [*any]]] + [Obtain an address object that represents any address. ] + ] + + [ + [[link asio.reference.ip__address_v6.from_string [*from_string]]] + [(Deprecated: Use make_address_v6().) Create an IPv6 address from an IP address string. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_link_local [*is_link_local]]] + [Determine whether the address is link local. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_loopback [*is_loopback]]] + [Determine whether the address is a loopback address. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_multicast [*is_multicast]]] + [Determine whether the address is a multicast address. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_multicast_global [*is_multicast_global]]] + [Determine whether the address is a global multicast address. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_multicast_link_local [*is_multicast_link_local]]] + [Determine whether the address is a link-local multicast address. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_multicast_node_local [*is_multicast_node_local]]] + [Determine whether the address is a node-local multicast address. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_multicast_org_local [*is_multicast_org_local]]] + [Determine whether the address is a org-local multicast address. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_multicast_site_local [*is_multicast_site_local]]] + [Determine whether the address is a site-local multicast address. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_site_local [*is_site_local]]] + [Determine whether the address is site local. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_unspecified [*is_unspecified]]] + [Determine whether the address is unspecified. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_v4_compatible [*is_v4_compatible]]] + [(Deprecated: No replacement.) Determine whether the address is an IPv4-compatible address. ] + ] + + [ + [[link asio.reference.ip__address_v6.is_v4_mapped [*is_v4_mapped]]] + [Determine whether the address is a mapped IPv4 address. ] + ] + + [ + [[link asio.reference.ip__address_v6.loopback [*loopback]]] + [Obtain an address object that represents the loopback address. ] + ] + + [ + [[link asio.reference.ip__address_v6.operator_eq_ [*operator=]]] + [Assign from another address. ] + ] + + [ + [[link asio.reference.ip__address_v6.scope_id [*scope_id]]] + [The scope ID of the address. ] + ] + + [ + [[link asio.reference.ip__address_v6.to_bytes [*to_bytes]]] + [Get the address in bytes, in network byte order. ] + ] + + [ + [[link asio.reference.ip__address_v6.to_string [*to_string]]] + [Get the address as a string. ] + ] + + [ + [[link asio.reference.ip__address_v6.to_v4 [*to_v4]]] + [(Deprecated: Use make_address_v4().) Converts an IPv4-mapped or IPv4-compatible address to an IPv4 address. ] + ] + + [ + [[link asio.reference.ip__address_v6.v4_compatible [*v4_compatible]]] + [(Deprecated: No replacement.) Create an IPv4-compatible IPv6 address. ] + ] + + [ + [[link asio.reference.ip__address_v6.v4_mapped [*v4_mapped]]] + [(Deprecated: Use make_address_v6().) Create an IPv4-mapped IPv6 address. ] + ] + +] + +[heading Friends] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_v6.operator_not__eq_ [*operator!=]]] + [Compare two addresses for inequality. ] + ] + + [ + [[link asio.reference.ip__address_v6.operator_lt_ [*operator<]]] + [Compare addresses for ordering. ] + ] + + [ + [[link asio.reference.ip__address_v6.operator_lt__eq_ [*operator<=]]] + [Compare addresses for ordering. ] + ] + + [ + [[link asio.reference.ip__address_v6.operator_eq__eq_ [*operator==]]] + [Compare two addresses for equality. ] + ] + + [ + [[link asio.reference.ip__address_v6.operator_gt_ [*operator>]]] + [Compare addresses for ordering. ] + ] + + [ + [[link asio.reference.ip__address_v6.operator_gt__eq_ [*operator>=]]] + [Compare addresses for ordering. ] + ] + +] + +[heading Related Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_v6.make_address_v6 [*make_address_v6]]] + [Create an IPv6 address from raw bytes and scope ID. + + Create an IPv6 address from an IP address string. + + Createan IPv6 address from an IP address string. + + Create an IPv4-mapped IPv6 address from an IPv4 address. ] + ] + + [ + [[link asio.reference.ip__address_v6.make_network_v6 [*make_network_v6]]] + [Create an IPv6 network from an address and prefix length. ] + ] + + [ + [[link asio.reference.ip__address_v6.operator_lt__lt_ [*operator<<]]] + [Output an address as a string. + + Output a network as a string. ] + ] + +] + +The [link asio.reference.ip__address_v6 `ip::address_v6`] class provides the ability to use and manipulate IP version 6 addresses. + + +[heading Thread Safety] + +['Distinct] ['objects:] Safe. + +['Shared] ['objects:] Unsafe. + + + + +[heading Requirements] + +['Header: ][^asio/ip/address_iterator_v6.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[endsect] + +[section:ip__address_range_v4 ip::address_range_v4] + + +Represents a range of IPv4 addresses. + + + class address_range_v4 + + +[heading Types] +[table + [[Name][Description]] + + [ + + [[link asio.reference.ip__address_range_v4.iterator [*iterator]]] + [The type of an iterator that points into the range. ] + + ] + +] + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_range_v4.address_range_v4 [*address_range_v4]]] + [Construct an empty range. + + Construct an range that represents the given range of addresses. + + Copy constructor. ] + ] + + [ + [[link asio.reference.ip__address_range_v4.begin [*begin]]] + [Obtain an iterator that points to the start of the range. ] + ] + + [ + [[link asio.reference.ip__address_range_v4.empty [*empty]]] + [Determine whether the range is empty. ] + ] + + [ + [[link asio.reference.ip__address_range_v4.end [*end]]] + [Obtain an iterator that points to the end of the range. ] + ] + + [ + [[link asio.reference.ip__address_range_v4.find [*find]]] + [Find an address in the range. ] + ] + + [ + [[link asio.reference.ip__address_range_v4.operator_eq_ [*operator=]]] + [Assignment operator. ] + ] + + [ + [[link asio.reference.ip__address_range_v4.size [*size]]] + [Return the size of the range. ] + ] + +] + + +[heading Thread Safety] + +['Distinct] ['objects:] Safe. + +['Shared] ['objects:] Unsafe. + + + +[heading Requirements] + +['Header: ][^asio/ip/address_range_v4.hpp] + +['Convenience header: ][^asio.hpp] + +[section:address_range_v4 ip::address_range_v4::address_range_v4] + +[indexterm2 address_range_v4..ip::address_range_v4] +Construct an empty range. + + + ``[link asio.reference.ip__address_range_v4.address_range_v4.overload1 address_range_v4]``(); + `` [''''»''' [link asio.reference.ip__address_range_v4.address_range_v4.overload1 more...]]`` + + +Construct an range that represents the given range of addresses. + + + explicit ``[link asio.reference.ip__address_range_v4.address_range_v4.overload2 address_range_v4]``( + const address_iterator_v4 & first, + const address_iterator_v4 & last); + `` [''''»''' [link asio.reference.ip__address_range_v4.address_range_v4.overload2 more...]]`` + + +Copy constructor. + + + ``[link asio.reference.ip__address_range_v4.address_range_v4.overload3 address_range_v4]``( + const address_range_v4 & other); + `` [''''»''' [link asio.reference.ip__address_range_v4.address_range_v4.overload3 more...]]`` + + +[section:overload1 ip::address_range_v4::address_range_v4 (1 of 3 overloads)] + + +Construct an empty range. + + + address_range_v4(); + + + +[endsect] + + + +[section:overload2 ip::address_range_v4::address_range_v4 (2 of 3 overloads)] + + +Construct an range that represents the given range of addresses. + + + address_range_v4( + const address_iterator_v4 & first, + const address_iterator_v4 & last); + + + +[endsect] + + + +[section:overload3 ip::address_range_v4::address_range_v4 (3 of 3 overloads)] + + +Copy constructor. + + + address_range_v4( + const address_range_v4 & other); + + + +[endsect] + + +[endsect] + + +[section:begin ip::address_range_v4::begin] + +[indexterm2 begin..ip::address_range_v4] +Obtain an iterator that points to the start of the range. + + + iterator begin() const; + + + +[endsect] + + + +[section:empty ip::address_range_v4::empty] + +[indexterm2 empty..ip::address_range_v4] +Determine whether the range is empty. + + + bool empty() const; + + + +[endsect] + + + +[section:end ip::address_range_v4::end] + +[indexterm2 end..ip::address_range_v4] +Obtain an iterator that points to the end of the range. + + + iterator end() const; + + + +[endsect] + + + +[section:find ip::address_range_v4::find] + +[indexterm2 find..ip::address_range_v4] +Find an address in the range. + + + iterator find( + const address_v4 & addr) const; + + + +[endsect] + + + +[section:iterator ip::address_range_v4::iterator] + +[indexterm2 iterator..ip::address_range_v4] +The type of an iterator that points into the range. + + + typedef address_iterator_v4 iterator; + + +[heading Types] +[table + [[Name][Description]] + + [ + + [[link asio.reference.ip__address_iterator_v4.difference_type [*difference_type]]] + [Distance between two iterators. ] + + ] + + [ + + [[link asio.reference.ip__address_iterator_v4.iterator_category [*iterator_category]]] + [Denotes that the iterator satisfies the input iterator requirements. ] + + ] + + [ + + [[link asio.reference.ip__address_iterator_v4.pointer [*pointer]]] + [The type of a pointer to an element pointed to by the iterator. ] + + ] + + [ + + [[link asio.reference.ip__address_iterator_v4.reference [*reference]]] + [The type of a reference to an element pointed to by the iterator. ] + + ] + + [ + + [[link asio.reference.ip__address_iterator_v4.value_type [*value_type]]] + [The type of the elements pointed to by the iterator. ] + + ] + +] + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_iterator_v4.address_iterator_v4 [*address_iterator_v4]]] + [Construct an iterator that points to the specified address. + + Copy constructor. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v4.operator__star_ [*operator *]]] + [Dereference the iterator. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v4.operator_plus__plus_ [*operator++]]] + [Pre-increment operator. + + Post-increment operator. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v4.operator_minus__minus_ [*operator--]]] + [Pre-decrement operator. + + Post-decrement operator. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v4.operator_arrow_ [*operator->]]] + [Dereference the iterator. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v4.operator_eq_ [*operator=]]] + [Assignment operator. ] + ] + +] + +[heading Friends] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_iterator_v4.operator_not__eq_ [*operator!=]]] + [Compare two addresses for inequality. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v4.operator_eq__eq_ [*operator==]]] + [Compare two addresses for equality. ] + ] + +] + +In addition to satisfying the input iterator requirements, this iterator also supports decrement. + + +[heading Thread Safety] + +['Distinct] ['objects:] Safe. + +['Shared] ['objects:] Unsafe. + + + + +[heading Requirements] + +['Header: ][^asio/ip/address_range_v4.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:operator_eq_ ip::address_range_v4::operator=] + +[indexterm2 operator=..ip::address_range_v4] +Assignment operator. + + + address_range_v4 & operator=( + const address_range_v4 & other); + + + +[endsect] + + + +[section:size ip::address_range_v4::size] + +[indexterm2 size..ip::address_range_v4] +Return the size of the range. + + + std::size_t size() const; + + + +[endsect] + + + +[endsect] + +[section:ip__address_range_v6 ip::address_range_v6] + + +Represents a range of IPv6 addresses. + + + class address_range_v6 + + +[heading Types] +[table + [[Name][Description]] + + [ + + [[link asio.reference.ip__address_range_v6.iterator [*iterator]]] + [The type of an iterator that points into the range. ] + + ] + +] + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_range_v6.address_range_v6 [*address_range_v6]]] + [Construct an empty range. + + Construct an range that represents the given range of addresses. + + Copy constructor. ] + ] + + [ + [[link asio.reference.ip__address_range_v6.begin [*begin]]] + [Obtain an iterator that points to the start of the range. ] + ] + + [ + [[link asio.reference.ip__address_range_v6.empty [*empty]]] + [Determine whether the range is empty. ] + ] + + [ + [[link asio.reference.ip__address_range_v6.end [*end]]] + [Obtain an iterator that points to the end of the range. ] + ] + + [ + [[link asio.reference.ip__address_range_v6.find [*find]]] + [Find an address in the range. ] + ] + + [ + [[link asio.reference.ip__address_range_v6.operator_eq_ [*operator=]]] + [Assignment operator. ] + ] + +] + + +[heading Thread Safety] + +['Distinct] ['objects:] Safe. + +['Shared] ['objects:] Unsafe. + + + +[heading Requirements] + +['Header: ][^asio/ip/address_range_v6.hpp] + +['Convenience header: ][^asio.hpp] + +[section:address_range_v6 ip::address_range_v6::address_range_v6] + +[indexterm2 address_range_v6..ip::address_range_v6] +Construct an empty range. + + + ``[link asio.reference.ip__address_range_v6.address_range_v6.overload1 address_range_v6]``(); + `` [''''»''' [link asio.reference.ip__address_range_v6.address_range_v6.overload1 more...]]`` + + +Construct an range that represents the given range of addresses. + + + explicit ``[link asio.reference.ip__address_range_v6.address_range_v6.overload2 address_range_v6]``( + const address_iterator_v6 & first, + const address_iterator_v6 & last); + `` [''''»''' [link asio.reference.ip__address_range_v6.address_range_v6.overload2 more...]]`` + + +Copy constructor. + + + ``[link asio.reference.ip__address_range_v6.address_range_v6.overload3 address_range_v6]``( + const address_range_v6 & other); + `` [''''»''' [link asio.reference.ip__address_range_v6.address_range_v6.overload3 more...]]`` + + +[section:overload1 ip::address_range_v6::address_range_v6 (1 of 3 overloads)] + + +Construct an empty range. + + + address_range_v6(); + + + +[endsect] + + + +[section:overload2 ip::address_range_v6::address_range_v6 (2 of 3 overloads)] + + +Construct an range that represents the given range of addresses. + + + address_range_v6( + const address_iterator_v6 & first, + const address_iterator_v6 & last); + + + +[endsect] + + + +[section:overload3 ip::address_range_v6::address_range_v6 (3 of 3 overloads)] + + +Copy constructor. + + + address_range_v6( + const address_range_v6 & other); + + + +[endsect] + + +[endsect] + + +[section:begin ip::address_range_v6::begin] + +[indexterm2 begin..ip::address_range_v6] +Obtain an iterator that points to the start of the range. + + + iterator begin() const; + + + +[endsect] + + + +[section:empty ip::address_range_v6::empty] + +[indexterm2 empty..ip::address_range_v6] +Determine whether the range is empty. + + + bool empty() const; + + + +[endsect] + + + +[section:end ip::address_range_v6::end] + +[indexterm2 end..ip::address_range_v6] +Obtain an iterator that points to the end of the range. + + + iterator end() const; + + + +[endsect] + + + +[section:find ip::address_range_v6::find] + +[indexterm2 find..ip::address_range_v6] +Find an address in the range. + + + iterator find( + const address_v6 & addr) const; + + + +[endsect] + + + +[section:iterator ip::address_range_v6::iterator] + +[indexterm2 iterator..ip::address_range_v6] +The type of an iterator that points into the range. + + + typedef address_iterator_v6 iterator; + + +[heading Types] +[table + [[Name][Description]] + + [ + + [[link asio.reference.ip__address_iterator_v6.difference_type [*difference_type]]] + [Distance between two iterators. ] + + ] + + [ + + [[link asio.reference.ip__address_iterator_v6.iterator_category [*iterator_category]]] + [Denotes that the iterator satisfies the input iterator requirements. ] + + ] + + [ + + [[link asio.reference.ip__address_iterator_v6.pointer [*pointer]]] + [The type of a pointer to an element pointed to by the iterator. ] + + ] + + [ + + [[link asio.reference.ip__address_iterator_v6.reference [*reference]]] + [The type of a reference to an element pointed to by the iterator. ] + + ] + + [ + + [[link asio.reference.ip__address_iterator_v6.value_type [*value_type]]] + [The type of the elements pointed to by the iterator. ] + + ] + +] + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_iterator_v6.address_iterator_v6 [*address_iterator_v6]]] + [Construct an iterator that points to the specified address. + + Copy constructor. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v6.operator__star_ [*operator *]]] + [Dereference the iterator. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v6.operator_plus__plus_ [*operator++]]] + [Pre-increment operator. + + Post-increment operator. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v6.operator_minus__minus_ [*operator--]]] + [Pre-decrement operator. + + Post-decrement operator. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v6.operator_arrow_ [*operator->]]] + [Dereference the iterator. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v6.operator_eq_ [*operator=]]] + [Assignment operator. ] + ] + +] + +[heading Friends] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__address_iterator_v6.operator_not__eq_ [*operator!=]]] + [Compare two addresses for inequality. ] + ] + + [ + [[link asio.reference.ip__address_iterator_v6.operator_eq__eq_ [*operator==]]] + [Compare two addresses for equality. ] + ] + +] + +In addition to satisfying the input iterator requirements, this iterator also supports decrement. + + +[heading Thread Safety] + +['Distinct] ['objects:] Safe. + +['Shared] ['objects:] Unsafe. + + + + +[heading Requirements] + +['Header: ][^asio/ip/address_range_v6.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:operator_eq_ ip::address_range_v6::operator=] + +[indexterm2 operator=..ip::address_range_v6] +Assignment operator. + + + address_range_v6 & operator=( + const address_range_v6 & other); + + + +[endsect] + + + +[endsect] + [section:ip__address_v4 ip::address_v4] @@ -69390,12 +74728,23 @@ Create an IPv4 address from an unsigned long in host byte order. - Create an IPv4 address from an IP address string in dotted decimal form. ] + Create an IPv4 address from an IP address string in dotted decimal form. + + Create an IPv4 address from a IPv4-mapped IPv6 address. ] + ] + + [ + [[link asio.reference.ip__address_v4.make_network_v4 [*make_network_v4]]] + [Create an IPv4 network from an address and prefix length. + + Create an IPv4 network from an address and netmask. ] ] [ [[link asio.reference.ip__address_v4.operator_lt__lt_ [*operator<<]]] - [Output an address as a string. ] + [Output an address as a string. + + Output a network as a string. ] ] ] @@ -69830,7 +75179,16 @@ `` [''''»''' [link asio.reference.ip__address_v4.make_address_v4.overload6 more...]]`` -[section:overload1 ip::address_v4::make_address_v4 (1 of 6 overloads)] +Create an IPv4 address from a IPv4-mapped IPv6 address. + + + address_v4 ``[link asio.reference.ip__address_v4.make_address_v4.overload7 make_address_v4]``( + v4_mapped_t , + const address_v6 & v6_addr); + `` [''''»''' [link asio.reference.ip__address_v4.make_address_v4.overload7 more...]]`` + + +[section:overload1 ip::address_v4::make_address_v4 (1 of 7 overloads)] Create an IPv4 address from raw bytes in network order. @@ -69845,7 +75203,7 @@ -[section:overload2 ip::address_v4::make_address_v4 (2 of 6 overloads)] +[section:overload2 ip::address_v4::make_address_v4 (2 of 7 overloads)] Create an IPv4 address from an unsigned long in host byte order. @@ -69860,7 +75218,7 @@ -[section:overload3 ip::address_v4::make_address_v4 (3 of 6 overloads)] +[section:overload3 ip::address_v4::make_address_v4 (3 of 7 overloads)] Create an IPv4 address from an IP address string in dotted decimal form. @@ -69875,7 +75233,7 @@ -[section:overload4 ip::address_v4::make_address_v4 (4 of 6 overloads)] +[section:overload4 ip::address_v4::make_address_v4 (4 of 7 overloads)] Create an IPv4 address from an IP address string in dotted decimal form. @@ -69891,7 +75249,7 @@ -[section:overload5 ip::address_v4::make_address_v4 (5 of 6 overloads)] +[section:overload5 ip::address_v4::make_address_v4 (5 of 7 overloads)] Create an IPv4 address from an IP address string in dotted decimal form. @@ -69906,7 +75264,7 @@ -[section:overload6 ip::address_v4::make_address_v4 (6 of 6 overloads)] +[section:overload6 ip::address_v4::make_address_v4 (6 of 7 overloads)] Create an IPv4 address from an IP address string in dotted decimal form. @@ -69921,6 +75279,76 @@ [endsect] + +[section:overload7 ip::address_v4::make_address_v4 (7 of 7 overloads)] + + +Create an IPv4 address from a IPv4-mapped IPv6 address. + + + address_v4 make_address_v4( + v4_mapped_t , + const address_v6 & v6_addr); + + + +[endsect] + + +[endsect] + +[section:make_network_v4 ip::address_v4::make_network_v4] + +[indexterm2 make_network_v4..ip::address_v4] +Create an IPv4 network from an address and prefix length. + + + network_v4 ``[link asio.reference.ip__address_v4.make_network_v4.overload1 make_network_v4]``( + const address_v4 & addr, + unsigned short prefix_len); + `` [''''»''' [link asio.reference.ip__address_v4.make_network_v4.overload1 more...]]`` + + +Create an IPv4 network from an address and netmask. + + + network_v4 ``[link asio.reference.ip__address_v4.make_network_v4.overload2 make_network_v4]``( + const address_v4 & addr, + const address_v4 & mask); + `` [''''»''' [link asio.reference.ip__address_v4.make_network_v4.overload2 more...]]`` + + +[section:overload1 ip::address_v4::make_network_v4 (1 of 2 overloads)] + + +Create an IPv4 network from an address and prefix length. + + + network_v4 make_network_v4( + const address_v4 & addr, + unsigned short prefix_len); + + + +[endsect] + + + +[section:overload2 ip::address_v4::make_network_v4 (2 of 2 overloads)] + + +Create an IPv4 network from an address and netmask. + + + network_v4 make_network_v4( + const address_v4 & addr, + const address_v4 & mask); + + + +[endsect] + + [endsect] @@ -69982,7 +75410,6 @@ [endsect] - [section:operator_lt__lt_ ip::address_v4::operator<<] [indexterm2 operator<<..ip::address_v4] @@ -69992,6 +75419,33 @@ template< typename Elem, typename Traits> + std::basic_ostream< Elem, Traits > & ``[link asio.reference.ip__address_v4.operator_lt__lt_.overload1 operator<<]``( + std::basic_ostream< Elem, Traits > & os, + const address_v4 & addr); + `` [''''»''' [link asio.reference.ip__address_v4.operator_lt__lt_.overload1 more...]]`` + + +Output a network as a string. + + + template< + typename Elem, + typename Traits> + std::basic_ostream< Elem, Traits > & ``[link asio.reference.ip__address_v4.operator_lt__lt_.overload2 operator<<]``( + std::basic_ostream< Elem, Traits > & os, + const network_v4 & net); + `` [''''»''' [link asio.reference.ip__address_v4.operator_lt__lt_.overload2 more...]]`` + + +[section:overload1 ip::address_v4::operator<< (1 of 2 overloads)] + + +Output an address as a string. + + + template< + typename Elem, + typename Traits> std::basic_ostream< Elem, Traits > & operator<<( std::basic_ostream< Elem, Traits > & os, const address_v4 & addr); @@ -70023,6 +75477,48 @@ +[section:overload2 ip::address_v4::operator<< (2 of 2 overloads)] + + +Output a network as a string. + + + template< + typename Elem, + typename Traits> + std::basic_ostream< Elem, Traits > & operator<<( + std::basic_ostream< Elem, Traits > & os, + const network_v4 & net); + + +Used to output a human-readable string for a specified network. + + +[heading Parameters] + + +[variablelist + +[[os][The output stream to which the string will be written.]] + +[[net][The network to be written.]] + +] + + +[heading Return Value] + +The output stream. + + + + +[endsect] + + +[endsect] + + [section:operator_lt__eq_ ip::address_v4::operator<=] [indexterm2 operator<=..ip::address_v4] @@ -70393,12 +75889,21 @@ Create an IPv6 address from an IP address string. - Createan IPv6 address from an IP address string. ] + Createan IPv6 address from an IP address string. + + Create an IPv4-mapped IPv6 address from an IPv4 address. ] + ] + + [ + [[link asio.reference.ip__address_v6.make_network_v6 [*make_network_v6]]] + [Create an IPv6 network from an address and prefix length. ] ] [ [[link asio.reference.ip__address_v6.operator_lt__lt_ [*operator<<]]] - [Output an address as a string. ] + [Output an address as a string. + + Output a network as a string. ] ] ] @@ -70843,7 +76348,16 @@ `` [''''»''' [link asio.reference.ip__address_v6.make_address_v6.overload5 more...]]`` -[section:overload1 ip::address_v6::make_address_v6 (1 of 5 overloads)] +Create an IPv4-mapped IPv6 address from an IPv4 address. + + + address_v6 ``[link asio.reference.ip__address_v6.make_address_v6.overload6 make_address_v6]``( + v4_mapped_t , + const address_v4 & v4_addr); + `` [''''»''' [link asio.reference.ip__address_v6.make_address_v6.overload6 more...]]`` + + +[section:overload1 ip::address_v6::make_address_v6 (1 of 6 overloads)] Create an IPv6 address from raw bytes and scope ID. @@ -70859,7 +76373,7 @@ -[section:overload2 ip::address_v6::make_address_v6 (2 of 5 overloads)] +[section:overload2 ip::address_v6::make_address_v6 (2 of 6 overloads)] Create an IPv6 address from an IP address string. @@ -70874,7 +76388,7 @@ -[section:overload3 ip::address_v6::make_address_v6 (3 of 5 overloads)] +[section:overload3 ip::address_v6::make_address_v6 (3 of 6 overloads)] Create an IPv6 address from an IP address string. @@ -70890,7 +76404,7 @@ -[section:overload4 ip::address_v6::make_address_v6 (4 of 5 overloads)] +[section:overload4 ip::address_v6::make_address_v6 (4 of 6 overloads)] Createan IPv6 address from an IP address string. @@ -70905,7 +76419,7 @@ -[section:overload5 ip::address_v6::make_address_v6 (5 of 5 overloads)] +[section:overload5 ip::address_v6::make_address_v6 (5 of 6 overloads)] Create an IPv6 address from an IP address string. @@ -70920,9 +76434,41 @@ [endsect] + +[section:overload6 ip::address_v6::make_address_v6 (6 of 6 overloads)] + + +Create an IPv4-mapped IPv6 address from an IPv4 address. + + + address_v6 make_address_v6( + v4_mapped_t , + const address_v4 & v4_addr); + + + [endsect] +[endsect] + + +[section:make_network_v6 ip::address_v6::make_network_v6] + +[indexterm2 make_network_v6..ip::address_v6] +Create an IPv6 network from an address and prefix length. + + + network_v6 make_network_v6( + const address_v6 & addr, + unsigned short prefix_len); + + + +[endsect] + + + [section:operator_not__eq_ ip::address_v6::operator!=] [indexterm2 operator!=..ip::address_v6] @@ -70966,7 +76512,6 @@ [endsect] - [section:operator_lt__lt_ ip::address_v6::operator<<] [indexterm2 operator<<..ip::address_v6] @@ -70976,6 +76521,33 @@ template< typename Elem, typename Traits> + std::basic_ostream< Elem, Traits > & ``[link asio.reference.ip__address_v6.operator_lt__lt_.overload1 operator<<]``( + std::basic_ostream< Elem, Traits > & os, + const address_v6 & addr); + `` [''''»''' [link asio.reference.ip__address_v6.operator_lt__lt_.overload1 more...]]`` + + +Output a network as a string. + + + template< + typename Elem, + typename Traits> + std::basic_ostream< Elem, Traits > & ``[link asio.reference.ip__address_v6.operator_lt__lt_.overload2 operator<<]``( + std::basic_ostream< Elem, Traits > & os, + const network_v6 & net); + `` [''''»''' [link asio.reference.ip__address_v6.operator_lt__lt_.overload2 more...]]`` + + +[section:overload1 ip::address_v6::operator<< (1 of 2 overloads)] + + +Output an address as a string. + + + template< + typename Elem, + typename Traits> std::basic_ostream< Elem, Traits > & operator<<( std::basic_ostream< Elem, Traits > & os, const address_v6 & addr); @@ -71007,6 +76579,48 @@ +[section:overload2 ip::address_v6::operator<< (2 of 2 overloads)] + + +Output a network as a string. + + + template< + typename Elem, + typename Traits> + std::basic_ostream< Elem, Traits > & operator<<( + std::basic_ostream< Elem, Traits > & os, + const network_v6 & net); + + +Used to output a human-readable string for a specified network. + + +[heading Parameters] + + +[variablelist + +[[os][The output stream to which the string will be written.]] + +[[net][The network to be written.]] + +] + + +[heading Return Value] + +The output stream. + + + + +[endsect] + + +[endsect] + + [section:operator_lt__eq_ ip::address_v6::operator<=] [indexterm2 operator<=..ip::address_v6] @@ -71219,7 +76833,7 @@ [section:to_v4 ip::address_v6::to_v4] [indexterm2 to_v4..ip::address_v6] -(Deprecated: Use [link asio.reference.ip__make_address_v4 `ip::make_address_v4`].) Converts an IPv4-mapped or IPv4-compatible address to an IPv4 address. +(Deprecated: Use `make_address_v4()`.) Converts an IPv4-mapped or IPv4-compatible address to an IPv4 address. address_v4 to_v4() const; @@ -72190,7 +77804,7 @@ typename ``[link asio.reference.ResolveHandler ResolveHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.ip__basic_resolver.async_resolve.overload1 async_resolve]``( const query & q, - ResolveHandler handler); + ResolveHandler && handler); `` [''''»''' [link asio.reference.ip__basic_resolver.async_resolve.overload1 more...]]`` @@ -72201,7 +77815,7 @@ typename ``[link asio.reference.ResolveHandler ResolveHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.ip__basic_resolver.async_resolve.overload2 async_resolve]``( const endpoint_type & e, - ResolveHandler handler); + ResolveHandler && handler); `` [''''»''' [link asio.reference.ip__basic_resolver.async_resolve.overload2 more...]]`` @@ -72215,7 +77829,7 @@ typename ``[link asio.reference.ResolveHandler ResolveHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_resolve( const query & q, - ResolveHandler handler); + ResolveHandler && handler); This function is used to asynchronously resolve a query into a list of endpoint entries. @@ -72263,7 +77877,7 @@ typename ``[link asio.reference.ResolveHandler ResolveHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_resolve( const endpoint_type & e, - ResolveHandler handler); + ResolveHandler && handler); This function is used to asynchronously resolve an endpoint into a list of endpoint entries. @@ -75495,50 +81109,6 @@ [endsect] -[section:ip__make_address_v4 ip::make_address_v4] - -[indexterm1 ip::make_address_v4] -Create an IPv4 address from a IPv4-mapped IPv6 address. - - - address_v4 make_address_v4( - v4_mapped_t , - const address_v6 & v6_addr); - - -[heading Requirements] - -['Header: ][^asio/ip/address_v6.hpp] - -['Convenience header: ][^asio.hpp] - - -[endsect] - - - -[section:ip__make_address_v6 ip::make_address_v6] - -[indexterm1 ip::make_address_v6] -Create an IPv4-mapped IPv6 address from an IPv4 address. - - - address_v6 make_address_v6( - v4_mapped_t , - const address_v4 & v4_addr); - - -[heading Requirements] - -['Header: ][^asio/ip/address_v6.hpp] - -['Convenience header: ][^asio.hpp] - - -[endsect] - - - [section:ip__multicast__enable_loopback ip::multicast::enable_loopback] [indexterm1 ip::multicast::enable_loopback] @@ -75763,6 +81333,1041 @@ [endsect] +[section:ip__network_v4 ip::network_v4] + + +Represents an IPv4 network. + + + class network_v4 + + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__network_v4.address [*address]]] + [Obtain the address object specified when the network object was created. ] + ] + + [ + [[link asio.reference.ip__network_v4.broadcast [*broadcast]]] + [Obtain an address object that represents the network's broadcast address. ] + ] + + [ + [[link asio.reference.ip__network_v4.canonical [*canonical]]] + [Obtain the true network address, omitting any host bits. ] + ] + + [ + [[link asio.reference.ip__network_v4.hosts [*hosts]]] + [Obtain an address range corresponding to the hosts in the network. ] + ] + + [ + [[link asio.reference.ip__network_v4.is_host [*is_host]]] + [Test if network is a valid host address. ] + ] + + [ + [[link asio.reference.ip__network_v4.is_subnet_of [*is_subnet_of]]] + [Test if a network is a real subnet of another network. ] + ] + + [ + [[link asio.reference.ip__network_v4.netmask [*netmask]]] + [Obtain the netmask that was specified when the network object was created. ] + ] + + [ + [[link asio.reference.ip__network_v4.network [*network]]] + [Obtain an address object that represents the network address. ] + ] + + [ + [[link asio.reference.ip__network_v4.network_v4 [*network_v4]]] + [Default constructor. + + Construct a network based on the specified address and prefix length. + + Construct network based on the specified address and netmask. + + Copy constructor. ] + ] + + [ + [[link asio.reference.ip__network_v4.operator_eq_ [*operator=]]] + [Assign from another network. ] + ] + + [ + [[link asio.reference.ip__network_v4.prefix_length [*prefix_length]]] + [Obtain the prefix length that was specified when the network object was created. ] + ] + + [ + [[link asio.reference.ip__network_v4.to_string [*to_string]]] + [Get the network as an address in dotted decimal format. ] + ] + +] + +[heading Friends] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__network_v4.operator_not__eq_ [*operator!=]]] + [Compare two networks for inequality. ] + ] + + [ + [[link asio.reference.ip__network_v4.operator_eq__eq_ [*operator==]]] + [Compare two networks for equality. ] + ] + +] + +[heading Related Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__network_v4.make_network_v4 [*make_network_v4]]] + [Create an IPv4 network from a string containing IP address and prefix length. + + Create an IPv4 address from an IP address string in dotted decimal form. ] + ] + +] + +The [link asio.reference.ip__network_v4 `ip::network_v4`] class provides the ability to use and manipulate IP version 4 networks. + + +[heading Thread Safety] + +['Distinct] ['objects:] Safe. + +['Shared] ['objects:] Unsafe. + + + +[heading Requirements] + +['Header: ][^asio/ip/network_v4.hpp] + +['Convenience header: ][^asio.hpp] + + +[section:address ip::network_v4::address] + +[indexterm2 address..ip::network_v4] +Obtain the address object specified when the network object was created. + + + address_v4 address() const; + + + +[endsect] + + + +[section:broadcast ip::network_v4::broadcast] + +[indexterm2 broadcast..ip::network_v4] +Obtain an address object that represents the network's broadcast address. + + + address_v4 broadcast() const; + + + +[endsect] + + + +[section:canonical ip::network_v4::canonical] + +[indexterm2 canonical..ip::network_v4] +Obtain the true network address, omitting any host bits. + + + network_v4 canonical() const; + + + +[endsect] + + + +[section:hosts ip::network_v4::hosts] + +[indexterm2 hosts..ip::network_v4] +Obtain an address range corresponding to the hosts in the network. + + + address_range_v4 hosts() const; + + + +[endsect] + + + +[section:is_host ip::network_v4::is_host] + +[indexterm2 is_host..ip::network_v4] +Test if network is a valid host address. + + + bool is_host() const; + + + +[endsect] + + + +[section:is_subnet_of ip::network_v4::is_subnet_of] + +[indexterm2 is_subnet_of..ip::network_v4] +Test if a network is a real subnet of another network. + + + bool is_subnet_of( + const network_v4 & other) const; + + + +[endsect] + + +[section:make_network_v4 ip::network_v4::make_network_v4] + +[indexterm2 make_network_v4..ip::network_v4] +Create an IPv4 network from a string containing IP address and prefix length. + + + network_v4 ``[link asio.reference.ip__network_v4.make_network_v4.overload1 make_network_v4]``( + const char * str); + `` [''''»''' [link asio.reference.ip__network_v4.make_network_v4.overload1 more...]]`` + + +Create an IPv4 address from an IP address string in dotted decimal form. + + + network_v4 ``[link asio.reference.ip__network_v4.make_network_v4.overload2 make_network_v4]``( + const char * str, + asio::error_code & ec); + `` [''''»''' [link asio.reference.ip__network_v4.make_network_v4.overload2 more...]]`` + + network_v4 ``[link asio.reference.ip__network_v4.make_network_v4.overload3 make_network_v4]``( + const std::string & str); + `` [''''»''' [link asio.reference.ip__network_v4.make_network_v4.overload3 more...]]`` + + network_v4 ``[link asio.reference.ip__network_v4.make_network_v4.overload4 make_network_v4]``( + const std::string & str, + asio::error_code & ec); + `` [''''»''' [link asio.reference.ip__network_v4.make_network_v4.overload4 more...]]`` + + +[section:overload1 ip::network_v4::make_network_v4 (1 of 4 overloads)] + + +Create an IPv4 network from a string containing IP address and prefix length. + + + network_v4 make_network_v4( + const char * str); + + + +[endsect] + + + +[section:overload2 ip::network_v4::make_network_v4 (2 of 4 overloads)] + + +Create an IPv4 address from an IP address string in dotted decimal form. + + + network_v4 make_network_v4( + const char * str, + asio::error_code & ec); + + + +[endsect] + + + +[section:overload3 ip::network_v4::make_network_v4 (3 of 4 overloads)] + + +Create an IPv4 address from an IP address string in dotted decimal form. + + + network_v4 make_network_v4( + const std::string & str); + + + +[endsect] + + + +[section:overload4 ip::network_v4::make_network_v4 (4 of 4 overloads)] + + +Create an IPv4 address from an IP address string in dotted decimal form. + + + network_v4 make_network_v4( + const std::string & str, + asio::error_code & ec); + + + +[endsect] + + +[endsect] + + +[section:netmask ip::network_v4::netmask] + +[indexterm2 netmask..ip::network_v4] +Obtain the netmask that was specified when the network object was created. + + + address_v4 netmask() const; + + + +[endsect] + + + +[section:network ip::network_v4::network] + +[indexterm2 network..ip::network_v4] +Obtain an address object that represents the network address. + + + address_v4 network() const; + + + +[endsect] + + +[section:network_v4 ip::network_v4::network_v4] + +[indexterm2 network_v4..ip::network_v4] +Default constructor. + + + ``[link asio.reference.ip__network_v4.network_v4.overload1 network_v4]``(); + `` [''''»''' [link asio.reference.ip__network_v4.network_v4.overload1 more...]]`` + + +Construct a network based on the specified address and prefix length. + + + ``[link asio.reference.ip__network_v4.network_v4.overload2 network_v4]``( + const address_v4 & addr, + unsigned short prefix_len); + `` [''''»''' [link asio.reference.ip__network_v4.network_v4.overload2 more...]]`` + + +Construct network based on the specified address and netmask. + + + ``[link asio.reference.ip__network_v4.network_v4.overload3 network_v4]``( + const address_v4 & addr, + const address_v4 & mask); + `` [''''»''' [link asio.reference.ip__network_v4.network_v4.overload3 more...]]`` + + +Copy constructor. + + + ``[link asio.reference.ip__network_v4.network_v4.overload4 network_v4]``( + const network_v4 & other); + `` [''''»''' [link asio.reference.ip__network_v4.network_v4.overload4 more...]]`` + + +[section:overload1 ip::network_v4::network_v4 (1 of 4 overloads)] + + +Default constructor. + + + network_v4(); + + + +[endsect] + + + +[section:overload2 ip::network_v4::network_v4 (2 of 4 overloads)] + + +Construct a network based on the specified address and prefix length. + + + network_v4( + const address_v4 & addr, + unsigned short prefix_len); + + + +[endsect] + + + +[section:overload3 ip::network_v4::network_v4 (3 of 4 overloads)] + + +Construct network based on the specified address and netmask. + + + network_v4( + const address_v4 & addr, + const address_v4 & mask); + + + +[endsect] + + + +[section:overload4 ip::network_v4::network_v4 (4 of 4 overloads)] + + +Copy constructor. + + + network_v4( + const network_v4 & other); + + + +[endsect] + + +[endsect] + + +[section:operator_not__eq_ ip::network_v4::operator!=] + +[indexterm2 operator!=..ip::network_v4] +Compare two networks for inequality. + + + friend bool operator!=( + const network_v4 & a, + const network_v4 & b); + + +[heading Requirements] + +['Header: ][^asio/ip/network_v4.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:operator_eq_ ip::network_v4::operator=] + +[indexterm2 operator=..ip::network_v4] +Assign from another network. + + + network_v4 & operator=( + const network_v4 & other); + + + +[endsect] + + + +[section:operator_eq__eq_ ip::network_v4::operator==] + +[indexterm2 operator==..ip::network_v4] +Compare two networks for equality. + + + friend bool operator==( + const network_v4 & a, + const network_v4 & b); + + +[heading Requirements] + +['Header: ][^asio/ip/network_v4.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:prefix_length ip::network_v4::prefix_length] + +[indexterm2 prefix_length..ip::network_v4] +Obtain the prefix length that was specified when the network object was created. + + + unsigned short prefix_length() const; + + + +[endsect] + + +[section:to_string ip::network_v4::to_string] + +[indexterm2 to_string..ip::network_v4] +Get the network as an address in dotted decimal format. + + + std::string ``[link asio.reference.ip__network_v4.to_string.overload1 to_string]``() const; + `` [''''»''' [link asio.reference.ip__network_v4.to_string.overload1 more...]]`` + + std::string ``[link asio.reference.ip__network_v4.to_string.overload2 to_string]``( + asio::error_code & ec) const; + `` [''''»''' [link asio.reference.ip__network_v4.to_string.overload2 more...]]`` + + +[section:overload1 ip::network_v4::to_string (1 of 2 overloads)] + + +Get the network as an address in dotted decimal format. + + + std::string to_string() const; + + + +[endsect] + + + +[section:overload2 ip::network_v4::to_string (2 of 2 overloads)] + + +Get the network as an address in dotted decimal format. + + + std::string to_string( + asio::error_code & ec) const; + + + +[endsect] + + +[endsect] + + +[endsect] + +[section:ip__network_v6 ip::network_v6] + + +Represents an IPv6 network. + + + class network_v6 + + +[heading Member Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__network_v6.address [*address]]] + [Obtain the address object specified when the network object was created. ] + ] + + [ + [[link asio.reference.ip__network_v6.canonical [*canonical]]] + [Obtain the true network address, omitting any host bits. ] + ] + + [ + [[link asio.reference.ip__network_v6.hosts [*hosts]]] + [Obtain an address range corresponding to the hosts in the network. ] + ] + + [ + [[link asio.reference.ip__network_v6.is_host [*is_host]]] + [Test if network is a valid host address. ] + ] + + [ + [[link asio.reference.ip__network_v6.is_subnet_of [*is_subnet_of]]] + [Test if a network is a real subnet of another network. ] + ] + + [ + [[link asio.reference.ip__network_v6.network [*network]]] + [Obtain an address object that represents the network address. ] + ] + + [ + [[link asio.reference.ip__network_v6.network_v6 [*network_v6]]] + [Default constructor. + + Construct a network based on the specified address and prefix length. + + Copy constructor. ] + ] + + [ + [[link asio.reference.ip__network_v6.operator_eq_ [*operator=]]] + [Assign from another network. ] + ] + + [ + [[link asio.reference.ip__network_v6.prefix_length [*prefix_length]]] + [Obtain the prefix length that was specified when the network object was created. ] + ] + + [ + [[link asio.reference.ip__network_v6.to_string [*to_string]]] + [Get the network as an address in dotted decimal format. ] + ] + +] + +[heading Friends] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__network_v6.operator_not__eq_ [*operator!=]]] + [Compare two networks for inequality. ] + ] + + [ + [[link asio.reference.ip__network_v6.operator_eq__eq_ [*operator==]]] + [Compare two networks for equality. ] + ] + +] + +[heading Related Functions] +[table + [[Name][Description]] + + [ + [[link asio.reference.ip__network_v6.make_network_v6 [*make_network_v6]]] + [Create an IPv6 network from a string containing IP address and prefix length. + + Create an IPv6 address from an IP address string in dotted decimal form. ] + ] + +] + +The [link asio.reference.ip__network_v6 `ip::network_v6`] class provides the ability to use and manipulate IP version 6 networks. + + +[heading Thread Safety] + +['Distinct] ['objects:] Safe. + +['Shared] ['objects:] Unsafe. + + + +[heading Requirements] + +['Header: ][^asio/ip/network_v6.hpp] + +['Convenience header: ][^asio.hpp] + + +[section:address ip::network_v6::address] + +[indexterm2 address..ip::network_v6] +Obtain the address object specified when the network object was created. + + + address_v6 address() const; + + + +[endsect] + + + +[section:canonical ip::network_v6::canonical] + +[indexterm2 canonical..ip::network_v6] +Obtain the true network address, omitting any host bits. + + + network_v6 canonical() const; + + + +[endsect] + + + +[section:hosts ip::network_v6::hosts] + +[indexterm2 hosts..ip::network_v6] +Obtain an address range corresponding to the hosts in the network. + + + address_range_v6 hosts() const; + + + +[endsect] + + + +[section:is_host ip::network_v6::is_host] + +[indexterm2 is_host..ip::network_v6] +Test if network is a valid host address. + + + bool is_host() const; + + + +[endsect] + + + +[section:is_subnet_of ip::network_v6::is_subnet_of] + +[indexterm2 is_subnet_of..ip::network_v6] +Test if a network is a real subnet of another network. + + + bool is_subnet_of( + const network_v6 & other) const; + + + +[endsect] + + +[section:make_network_v6 ip::network_v6::make_network_v6] + +[indexterm2 make_network_v6..ip::network_v6] +Create an IPv6 network from a string containing IP address and prefix length. + + + network_v6 ``[link asio.reference.ip__network_v6.make_network_v6.overload1 make_network_v6]``( + const char * str); + `` [''''»''' [link asio.reference.ip__network_v6.make_network_v6.overload1 more...]]`` + + +Create an IPv6 address from an IP address string in dotted decimal form. + + + network_v6 ``[link asio.reference.ip__network_v6.make_network_v6.overload2 make_network_v6]``( + const char * str, + asio::error_code & ec); + `` [''''»''' [link asio.reference.ip__network_v6.make_network_v6.overload2 more...]]`` + + network_v6 ``[link asio.reference.ip__network_v6.make_network_v6.overload3 make_network_v6]``( + const std::string & str); + `` [''''»''' [link asio.reference.ip__network_v6.make_network_v6.overload3 more...]]`` + + network_v6 ``[link asio.reference.ip__network_v6.make_network_v6.overload4 make_network_v6]``( + const std::string & str, + asio::error_code & ec); + `` [''''»''' [link asio.reference.ip__network_v6.make_network_v6.overload4 more...]]`` + + +[section:overload1 ip::network_v6::make_network_v6 (1 of 4 overloads)] + + +Create an IPv6 network from a string containing IP address and prefix length. + + + network_v6 make_network_v6( + const char * str); + + + +[endsect] + + + +[section:overload2 ip::network_v6::make_network_v6 (2 of 4 overloads)] + + +Create an IPv6 address from an IP address string in dotted decimal form. + + + network_v6 make_network_v6( + const char * str, + asio::error_code & ec); + + + +[endsect] + + + +[section:overload3 ip::network_v6::make_network_v6 (3 of 4 overloads)] + + +Create an IPv6 address from an IP address string in dotted decimal form. + + + network_v6 make_network_v6( + const std::string & str); + + + +[endsect] + + + +[section:overload4 ip::network_v6::make_network_v6 (4 of 4 overloads)] + + +Create an IPv6 address from an IP address string in dotted decimal form. + + + network_v6 make_network_v6( + const std::string & str, + asio::error_code & ec); + + + +[endsect] + + +[endsect] + + +[section:network ip::network_v6::network] + +[indexterm2 network..ip::network_v6] +Obtain an address object that represents the network address. + + + address_v6 network() const; + + + +[endsect] + + +[section:network_v6 ip::network_v6::network_v6] + +[indexterm2 network_v6..ip::network_v6] +Default constructor. + + + ``[link asio.reference.ip__network_v6.network_v6.overload1 network_v6]``(); + `` [''''»''' [link asio.reference.ip__network_v6.network_v6.overload1 more...]]`` + + +Construct a network based on the specified address and prefix length. + + + ``[link asio.reference.ip__network_v6.network_v6.overload2 network_v6]``( + const address_v6 & addr, + unsigned short prefix_len); + `` [''''»''' [link asio.reference.ip__network_v6.network_v6.overload2 more...]]`` + + +Copy constructor. + + + ``[link asio.reference.ip__network_v6.network_v6.overload3 network_v6]``( + const network_v6 & other); + `` [''''»''' [link asio.reference.ip__network_v6.network_v6.overload3 more...]]`` + + +[section:overload1 ip::network_v6::network_v6 (1 of 3 overloads)] + + +Default constructor. + + + network_v6(); + + + +[endsect] + + + +[section:overload2 ip::network_v6::network_v6 (2 of 3 overloads)] + + +Construct a network based on the specified address and prefix length. + + + network_v6( + const address_v6 & addr, + unsigned short prefix_len); + + + +[endsect] + + + +[section:overload3 ip::network_v6::network_v6 (3 of 3 overloads)] + + +Copy constructor. + + + network_v6( + const network_v6 & other); + + + +[endsect] + + +[endsect] + + +[section:operator_not__eq_ ip::network_v6::operator!=] + +[indexterm2 operator!=..ip::network_v6] +Compare two networks for inequality. + + + friend bool operator!=( + const network_v6 & a, + const network_v6 & b); + + +[heading Requirements] + +['Header: ][^asio/ip/network_v6.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:operator_eq_ ip::network_v6::operator=] + +[indexterm2 operator=..ip::network_v6] +Assign from another network. + + + network_v6 & operator=( + const network_v6 & other); + + + +[endsect] + + + +[section:operator_eq__eq_ ip::network_v6::operator==] + +[indexterm2 operator==..ip::network_v6] +Compare two networks for equality. + + + friend bool operator==( + const network_v6 & a, + const network_v6 & b); + + +[heading Requirements] + +['Header: ][^asio/ip/network_v6.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + +[section:prefix_length ip::network_v6::prefix_length] + +[indexterm2 prefix_length..ip::network_v6] +Obtain the prefix length that was specified when the network object was created. + + + unsigned short prefix_length() const; + + + +[endsect] + + +[section:to_string ip::network_v6::to_string] + +[indexterm2 to_string..ip::network_v6] +Get the network as an address in dotted decimal format. + + + std::string ``[link asio.reference.ip__network_v6.to_string.overload1 to_string]``() const; + `` [''''»''' [link asio.reference.ip__network_v6.to_string.overload1 more...]]`` + + std::string ``[link asio.reference.ip__network_v6.to_string.overload2 to_string]``( + asio::error_code & ec) const; + `` [''''»''' [link asio.reference.ip__network_v6.to_string.overload2 more...]]`` + + +[section:overload1 ip::network_v6::to_string (1 of 2 overloads)] + + +Get the network as an address in dotted decimal format. + + + std::string to_string() const; + + + +[endsect] + + + +[section:overload2 ip::network_v6::to_string (2 of 2 overloads)] + + +Get the network as an address in dotted decimal format. + + + std::string to_string( + asio::error_code & ec) const; + + + +[endsect] + + +[endsect] + + +[endsect] + [section:ip__resolver_query_base ip::resolver_query_base] @@ -76105,7 +82710,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.ip__resolver_service.async_resolve.overload1 async_resolve]``( implementation_type & impl, const query_type & query, - ResolveHandler handler); + ResolveHandler && handler); `` [''''»''' [link asio.reference.ip__resolver_service.async_resolve.overload1 more...]]`` @@ -76117,7 +82722,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.ip__resolver_service.async_resolve.overload2 async_resolve]``( implementation_type & impl, const endpoint_type & endpoint, - ResolveHandler handler); + ResolveHandler && handler); `` [''''»''' [link asio.reference.ip__resolver_service.async_resolve.overload2 more...]]`` @@ -76132,7 +82737,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_resolve( implementation_type & impl, const query_type & query, - ResolveHandler handler); + ResolveHandler && handler); @@ -76151,7 +82756,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_resolve( implementation_type & impl, const endpoint_type & endpoint, - ResolveHandler handler); + ResolveHandler && handler); @@ -76940,6 +83545,11 @@ ] [ + [[link asio.reference.basic_socket_acceptor.async_wait [*async_wait]]] + [Asynchronously wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. ] + ] + + [ [[link asio.reference.basic_socket_acceptor.basic_socket_acceptor [*basic_socket_acceptor]]] [Construct an acceptor without opening it. @@ -77040,6 +83650,11 @@ [Set an option on the acceptor. ] ] + [ + [[link asio.reference.basic_socket_acceptor.wait [*wait]]] + [Wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. ] + ] + ] [heading Protected Member Functions] @@ -79262,6 +85877,26 @@ [endsect] +[section:is_dynamic_buffer_sequence is_dynamic_buffer_sequence] + + +Trait to determine whether a type satisfies the DynamicBufferSequence requirements. + + + template< + typename T> + struct is_dynamic_buffer_sequence + + +[heading Requirements] + +['Header: ][^asio/buffer.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + [section:is_executor is_executor] @@ -81111,6 +87746,11 @@ ] [ + [[link asio.reference.basic_socket_acceptor.async_wait [*async_wait]]] + [Asynchronously wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. ] + ] + + [ [[link asio.reference.basic_socket_acceptor.basic_socket_acceptor [*basic_socket_acceptor]]] [Construct an acceptor without opening it. @@ -81211,6 +87851,11 @@ [Set an option on the acceptor. ] ] + [ + [[link asio.reference.basic_socket_acceptor.wait [*wait]]] + [Wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. ] + ] + ] [heading Protected Member Functions] @@ -82090,7 +88735,8 @@ typename ExecutionContext> executor_work< typename associated_executor< T, typename ExecutionContext::executor_type >::type > ``[link asio.reference.make_work.overload5 make_work]``( const T & t, - ExecutionContext & ctx); + ExecutionContext & ctx, + typename enable_if<!is_executor< T >::value &&!is_convertible< T &, execution_context & >::value >::type * = 0); `` [''''»''' [link asio.reference.make_work.overload5 more...]]`` [heading Requirements] @@ -82185,7 +88831,8 @@ typename ExecutionContext> executor_work< typename associated_executor< T, typename ExecutionContext::executor_type >::type > make_work( const T & t, - ExecutionContext & ctx); + ExecutionContext & ctx, + typename enable_if<!is_executor< T >::value &&!is_convertible< T &, execution_context & >::value >::type * = 0); @@ -82853,14 +89500,14 @@ template< typename Function> packaged_token< typename decay< Function >::type, std::allocator< void > > ``[link asio.reference.package.overload1 package]``( - Function function); + Function && function); `` [''''»''' [link asio.reference.package.overload1 more...]]`` template< typename Function, typename Allocator> packaged_token< typename decay< Function >::type, Allocator > ``[link asio.reference.package.overload2 package]``( - Function function, + Function && function, const Allocator & a); `` [''''»''' [link asio.reference.package.overload2 more...]]`` @@ -82880,7 +89527,7 @@ template< typename Function> packaged_token< typename decay< Function >::type, std::allocator< void > > package( - Function function); + Function && function); The `package` function is used to adapt a function object as a packaged task. When this adapter is passed as a completion token to an asynchronous operation, the result of the function object is retuned via a std::future. @@ -82919,7 +89566,7 @@ typename Function, typename Allocator> packaged_token< typename decay< Function >::type, Allocator > package( - Function function, + Function && function, const Allocator & a); @@ -83569,7 +90216,7 @@ typename ``[link asio.reference.WaitHandler WaitHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( wait_type w, - WaitHandler handler); + WaitHandler && handler); This function is used to perform an asynchronous wait for a descriptor to enter a ready to read, write or error condition state. @@ -85409,7 +92056,7 @@ typename ``[link asio.reference.ReadHandler ReadHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_read_some( const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously read data from the stream descriptor. The function call always returns immediately. @@ -85468,7 +92115,7 @@ typename ``[link asio.reference.WaitHandler WaitHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( wait_type w, - WaitHandler handler); + WaitHandler && handler); This function is used to perform an asynchronous wait for a descriptor to enter a ready to read, write or error condition state. @@ -85533,7 +92180,7 @@ typename ``[link asio.reference.WriteHandler WriteHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_write_some( const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); This function is used to asynchronously write data to the stream descriptor. The function call always returns immediately. @@ -87931,7 +94578,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_read_some( implementation_type & impl, const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); @@ -87950,7 +94597,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( implementation_type & impl, descriptor_base::wait_type w, - WaitHandler handler); + WaitHandler && handler); @@ -87970,7 +94617,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_write_some( implementation_type & impl, const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); @@ -88399,7 +95046,7 @@ template< typename CompletionToken> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.post.overload1 post]``( - CompletionToken token); + CompletionToken && token); `` [''''»''' [link asio.reference.post.overload1 more...]]`` template< @@ -88407,7 +95054,7 @@ typename CompletionToken> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.post.overload2 post]``( const Executor & ex, - CompletionToken token, + CompletionToken && token, typename enable_if< is_executor< Executor >::value >::type * = 0); `` [''''»''' [link asio.reference.post.overload2 more...]]`` @@ -88416,7 +95063,7 @@ typename CompletionToken> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.post.overload3 post]``( ExecutionContext & ctx, - CompletionToken token, + CompletionToken && token, typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type * = 0); `` [''''»''' [link asio.reference.post.overload3 more...]]`` @@ -88436,7 +95083,7 @@ template< typename CompletionToken> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` post( - CompletionToken token); + CompletionToken && token); This function submits an object for execution using the object's associated executor. The function object is queued for execution, and is never called from the current thread prior to returning from `post()`. @@ -88479,7 +95126,7 @@ typename CompletionToken> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` post( const Executor & ex, - CompletionToken token, + CompletionToken && token, typename enable_if< is_executor< Executor >::value >::type * = 0); @@ -88529,7 +95176,7 @@ typename CompletionToken> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` post( ExecutionContext & ctx, - CompletionToken token, + CompletionToken && token, typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type * = 0); @@ -88829,7 +95476,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_connect( implementation_type & impl, const endpoint_type & peer_endpoint, - ConnectHandler handler); + ConnectHandler && handler); @@ -88850,7 +95497,7 @@ implementation_type & impl, const MutableBufferSequence & buffers, socket_base::message_flags flags, - ReadHandler handler); + ReadHandler && handler); @@ -88872,7 +95519,7 @@ const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, socket_base::message_flags flags, - ReadHandler handler); + ReadHandler && handler); @@ -88893,7 +95540,7 @@ implementation_type & impl, const ConstBufferSequence & buffers, socket_base::message_flags flags, - WriteHandler handler); + WriteHandler && handler); @@ -88915,7 +95562,7 @@ const ConstBufferSequence & buffers, const endpoint_type & destination, socket_base::message_flags flags, - WriteHandler handler); + WriteHandler && handler); @@ -88934,7 +95581,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( implementation_type & impl, socket_base::wait_type w, - WaitHandler handler); + WaitHandler && handler); @@ -89621,7 +96268,8 @@ typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``> std::size_t ``[link asio.reference.read.overload1 read]``( SyncReadStream & s, - const MutableBufferSequence & buffers); + const MutableBufferSequence & buffers, + typename enable_if< is_mutable_buffer_sequence< MutableBufferSequence >::value >::type * = 0); `` [''''»''' [link asio.reference.read.overload1 more...]]`` template< @@ -89630,7 +96278,8 @@ std::size_t ``[link asio.reference.read.overload2 read]``( SyncReadStream & s, const MutableBufferSequence & buffers, - asio::error_code & ec); + asio::error_code & ec, + typename enable_if< is_mutable_buffer_sequence< MutableBufferSequence >::value >::type * = 0); `` [''''»''' [link asio.reference.read.overload2 more...]]`` template< @@ -89640,7 +96289,8 @@ std::size_t ``[link asio.reference.read.overload3 read]``( SyncReadStream & s, const MutableBufferSequence & buffers, - CompletionCondition completion_condition); + CompletionCondition completion_condition, + typename enable_if< is_mutable_buffer_sequence< MutableBufferSequence >::value >::type * = 0); `` [''''»''' [link asio.reference.read.overload3 more...]]`` template< @@ -89651,46 +96301,89 @@ SyncReadStream & s, const MutableBufferSequence & buffers, CompletionCondition completion_condition, - asio::error_code & ec); + asio::error_code & ec, + typename enable_if< is_mutable_buffer_sequence< MutableBufferSequence >::value >::type * = 0); `` [''''»''' [link asio.reference.read.overload4 more...]]`` template< typename ``[link asio.reference.SyncReadStream SyncReadStream]``, - typename Allocator> + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``> std::size_t ``[link asio.reference.read.overload5 read]``( SyncReadStream & s, - basic_streambuf< Allocator > & b); + DynamicBufferSequence && buffers, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); `` [''''»''' [link asio.reference.read.overload5 more...]]`` template< typename ``[link asio.reference.SyncReadStream SyncReadStream]``, - typename Allocator> + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``> std::size_t ``[link asio.reference.read.overload6 read]``( SyncReadStream & s, - basic_streambuf< Allocator > & b, - asio::error_code & ec); + DynamicBufferSequence && buffers, + asio::error_code & ec, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); `` [''''»''' [link asio.reference.read.overload6 more...]]`` template< typename ``[link asio.reference.SyncReadStream SyncReadStream]``, - typename Allocator, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, typename CompletionCondition> std::size_t ``[link asio.reference.read.overload7 read]``( SyncReadStream & s, - basic_streambuf< Allocator > & b, - CompletionCondition completion_condition); + DynamicBufferSequence && buffers, + CompletionCondition completion_condition, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); `` [''''»''' [link asio.reference.read.overload7 more...]]`` template< typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename CompletionCondition> + std::size_t ``[link asio.reference.read.overload8 read]``( + SyncReadStream & s, + DynamicBufferSequence && buffers, + CompletionCondition completion_condition, + asio::error_code & ec, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); + `` [''''»''' [link asio.reference.read.overload8 more...]]`` + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename Allocator> + std::size_t ``[link asio.reference.read.overload9 read]``( + SyncReadStream & s, + basic_streambuf< Allocator > & b); + `` [''''»''' [link asio.reference.read.overload9 more...]]`` + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename Allocator> + std::size_t ``[link asio.reference.read.overload10 read]``( + SyncReadStream & s, + basic_streambuf< Allocator > & b, + asio::error_code & ec); + `` [''''»''' [link asio.reference.read.overload10 more...]]`` + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, typename Allocator, typename CompletionCondition> - std::size_t ``[link asio.reference.read.overload8 read]``( + std::size_t ``[link asio.reference.read.overload11 read]``( + SyncReadStream & s, + basic_streambuf< Allocator > & b, + CompletionCondition completion_condition); + `` [''''»''' [link asio.reference.read.overload11 more...]]`` + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename Allocator, + typename CompletionCondition> + std::size_t ``[link asio.reference.read.overload12 read]``( SyncReadStream & s, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, asio::error_code & ec); - `` [''''»''' [link asio.reference.read.overload8 more...]]`` + `` [''''»''' [link asio.reference.read.overload12 more...]]`` [heading Requirements] @@ -89699,7 +96392,7 @@ ['Convenience header: ][^asio.hpp] -[section:overload1 read (1 of 8 overloads)] +[section:overload1 read (1 of 12 overloads)] Attempt to read a certain amount of data from a stream before returning. @@ -89710,7 +96403,8 @@ typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``> std::size_t read( SyncReadStream & s, - const MutableBufferSequence & buffers); + const MutableBufferSequence & buffers, + typename enable_if< is_mutable_buffer_sequence< MutableBufferSequence >::value >::type * = 0); This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true: @@ -89779,7 +96473,7 @@ -[section:overload2 read (2 of 8 overloads)] +[section:overload2 read (2 of 12 overloads)] Attempt to read a certain amount of data from a stream before returning. @@ -89791,7 +96485,8 @@ std::size_t read( SyncReadStream & s, const MutableBufferSequence & buffers, - asio::error_code & ec); + asio::error_code & ec, + typename enable_if< is_mutable_buffer_sequence< MutableBufferSequence >::value >::type * = 0); This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true: @@ -89852,7 +96547,7 @@ -[section:overload3 read (3 of 8 overloads)] +[section:overload3 read (3 of 12 overloads)] Attempt to read a certain amount of data from a stream before returning. @@ -89865,7 +96560,8 @@ std::size_t read( SyncReadStream & s, const MutableBufferSequence & buffers, - CompletionCondition completion_condition); + CompletionCondition completion_condition, + typename enable_if< is_mutable_buffer_sequence< MutableBufferSequence >::value >::type * = 0); This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true: @@ -89935,7 +96631,7 @@ -[section:overload4 read (4 of 8 overloads)] +[section:overload4 read (4 of 12 overloads)] Attempt to read a certain amount of data from a stream before returning. @@ -89949,7 +96645,8 @@ SyncReadStream & s, const MutableBufferSequence & buffers, CompletionCondition completion_condition, - asio::error_code & ec); + asio::error_code & ec, + typename enable_if< is_mutable_buffer_sequence< MutableBufferSequence >::value >::type * = 0); This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true: @@ -90000,7 +96697,281 @@ -[section:overload5 read (5 of 8 overloads)] +[section:overload5 read (5 of 12 overloads)] + + +Attempt to read a certain amount of data from a stream before returning. + + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``> + std::size_t read( + SyncReadStream & s, + DynamicBufferSequence && buffers, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); + + +This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true: + + +* The specified dynamic buffer sequence is full (that is, it has reached maximum size). + + +* An error occurred. + +This operation is implemented in terms of zero or more calls to the stream's read\_some function. + + +[heading Parameters] + + +[variablelist + +[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]] + +[[buffers][The dynamic buffer sequence into which the data will be read.]] + +] + + +[heading Return Value] + +The number of bytes transferred. + + +[heading Exceptions] + + +[variablelist + +[[asio::system_error][Thrown on failure.]] + +] + + +[heading Remarks] + +This overload is equivalent to calling: + + asio::read( + s, buffers, + asio::transfer_all()); + + + + + + + +[endsect] + + + +[section:overload6 read (6 of 12 overloads)] + + +Attempt to read a certain amount of data from a stream before returning. + + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``> + std::size_t read( + SyncReadStream & s, + DynamicBufferSequence && buffers, + asio::error_code & ec, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); + + +This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true: + + +* The supplied buffer is full (that is, it has reached maximum size). + + +* An error occurred. + +This operation is implemented in terms of zero or more calls to the stream's read\_some function. + + +[heading Parameters] + + +[variablelist + +[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]] + +[[buffers][The dynamic buffer sequence into which the data will be read.]] + +[[ec][Set to indicate what error occurred, if any.]] + +] + + +[heading Return Value] + +The number of bytes transferred. + + +[heading Remarks] + +This overload is equivalent to calling: + + asio::read( + s, buffers, + asio::transfer_all(), ec); + + + + + + + +[endsect] + + + +[section:overload7 read (7 of 12 overloads)] + + +Attempt to read a certain amount of data from a stream before returning. + + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename CompletionCondition> + std::size_t read( + SyncReadStream & s, + DynamicBufferSequence && buffers, + CompletionCondition completion_condition, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); + + +This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true: + + +* The specified dynamic buffer sequence is full (that is, it has reached maximum size). + + +* The completion\_condition function object returns 0. + +This operation is implemented in terms of zero or more calls to the stream's read\_some function. + + +[heading Parameters] + + +[variablelist + +[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]] + +[[buffers][The dynamic buffer sequence into which the data will be read.]] + +[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: +`` + std::size_t completion_condition( + // Result of latest read_some operation. + const asio::error_code& error, + + // Number of bytes transferred so far. + std::size_t bytes_transferred + ); +`` +A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's read\_some function.]] + +] + + +[heading Return Value] + +The number of bytes transferred. + + +[heading Exceptions] + + +[variablelist + +[[asio::system_error][Thrown on failure. ]] + +] + + + + +[endsect] + + + +[section:overload8 read (8 of 12 overloads)] + + +Attempt to read a certain amount of data from a stream before returning. + + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename CompletionCondition> + std::size_t read( + SyncReadStream & s, + DynamicBufferSequence && buffers, + CompletionCondition completion_condition, + asio::error_code & ec, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); + + +This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true: + + +* The specified dynamic buffer sequence is full (that is, it has reached maximum size). + + +* The completion\_condition function object returns 0. + +This operation is implemented in terms of zero or more calls to the stream's read\_some function. + + +[heading Parameters] + + +[variablelist + +[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]] + +[[buffers][The dynamic buffer sequence into which the data will be read.]] + +[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: +`` + std::size_t completion_condition( + // Result of latest read_some operation. + const asio::error_code& error, + + // Number of bytes transferred so far. + std::size_t bytes_transferred + ); +`` +A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's read\_some function.]] + +[[ec][Set to indicate what error occurred, if any.]] + +] + + +[heading Return Value] + +The number of bytes read. If an error occurs, returns the total number of bytes successfully transferred prior to the error. + + + + +[endsect] + + + +[section:overload9 read (9 of 12 overloads)] Attempt to read a certain amount of data from a stream before returning. @@ -90070,7 +97041,7 @@ -[section:overload6 read (6 of 8 overloads)] +[section:overload10 read (10 of 12 overloads)] Attempt to read a certain amount of data from a stream before returning. @@ -90133,7 +97104,7 @@ -[section:overload7 read (7 of 8 overloads)] +[section:overload11 read (11 of 12 overloads)] Attempt to read a certain amount of data from a stream before returning. @@ -90205,7 +97176,7 @@ -[section:overload8 read (8 of 8 overloads)] +[section:overload12 read (12 of 12 overloads)] Attempt to read a certain amount of data from a stream before returning. @@ -90956,88 +97927,189 @@ [section:read_until read_until] [indexterm1 read_until] -Read data into a streambuf until it contains a delimiter, matches a regular expression, or a function object indicates a match. +Read data into a dynamic buffer sequence, or into a streambuf, until it contains a delimiter, matches a regular expression, or a function object indicates a match. template< typename ``[link asio.reference.SyncReadStream SyncReadStream]``, - typename Allocator> + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``> std::size_t ``[link asio.reference.read_until.overload1 read_until]``( SyncReadStream & s, - asio::basic_streambuf< Allocator > & b, + DynamicBufferSequence && buffers, char delim); `` [''''»''' [link asio.reference.read_until.overload1 more...]]`` template< typename ``[link asio.reference.SyncReadStream SyncReadStream]``, - typename Allocator> + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``> std::size_t ``[link asio.reference.read_until.overload2 read_until]``( SyncReadStream & s, - asio::basic_streambuf< Allocator > & b, + DynamicBufferSequence && buffers, char delim, asio::error_code & ec); `` [''''»''' [link asio.reference.read_until.overload2 more...]]`` template< typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, typename Allocator> std::size_t ``[link asio.reference.read_until.overload3 read_until]``( SyncReadStream & s, - asio::basic_streambuf< Allocator > & b, - const std::string & delim); + DynamicBufferSequence && buffers, + const std::basic_string< char, std::char_traits< char >, Allocator > & delim); `` [''''»''' [link asio.reference.read_until.overload3 more...]]`` template< typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, typename Allocator> std::size_t ``[link asio.reference.read_until.overload4 read_until]``( SyncReadStream & s, - asio::basic_streambuf< Allocator > & b, - const std::string & delim, + DynamicBufferSequence && buffers, + const std::basic_string< char, std::char_traits< char >, Allocator > & delim, asio::error_code & ec); `` [''''»''' [link asio.reference.read_until.overload4 more...]]`` template< typename ``[link asio.reference.SyncReadStream SyncReadStream]``, - typename Allocator> + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``> std::size_t ``[link asio.reference.read_until.overload5 read_until]``( SyncReadStream & s, - asio::basic_streambuf< Allocator > & b, + DynamicBufferSequence && buffers, const boost::regex & expr); `` [''''»''' [link asio.reference.read_until.overload5 more...]]`` template< typename ``[link asio.reference.SyncReadStream SyncReadStream]``, - typename Allocator> + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``> std::size_t ``[link asio.reference.read_until.overload6 read_until]``( SyncReadStream & s, - asio::basic_streambuf< Allocator > & b, + DynamicBufferSequence && buffers, const boost::regex & expr, asio::error_code & ec); `` [''''»''' [link asio.reference.read_until.overload6 more...]]`` template< typename ``[link asio.reference.SyncReadStream SyncReadStream]``, - typename Allocator, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, typename MatchCondition> std::size_t ``[link asio.reference.read_until.overload7 read_until]``( SyncReadStream & s, - asio::basic_streambuf< Allocator > & b, + DynamicBufferSequence && buffers, MatchCondition match_condition, typename enable_if< is_match_condition< MatchCondition >::value >::type * = 0); `` [''''»''' [link asio.reference.read_until.overload7 more...]]`` template< typename ``[link asio.reference.SyncReadStream SyncReadStream]``, - typename Allocator, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, typename MatchCondition> std::size_t ``[link asio.reference.read_until.overload8 read_until]``( SyncReadStream & s, + DynamicBufferSequence && buffers, + MatchCondition match_condition, + asio::error_code & ec, + typename enable_if< is_match_condition< MatchCondition >::value >::type * = 0); + `` [''''»''' [link asio.reference.read_until.overload8 more...]]`` + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename Allocator> + std::size_t ``[link asio.reference.read_until.overload9 read_until]``( + SyncReadStream & s, + asio::basic_streambuf< Allocator > & b, + char delim); + `` [''''»''' [link asio.reference.read_until.overload9 more...]]`` + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename Allocator> + std::size_t ``[link asio.reference.read_until.overload10 read_until]``( + SyncReadStream & s, + asio::basic_streambuf< Allocator > & b, + char delim, + asio::error_code & ec); + `` [''''»''' [link asio.reference.read_until.overload10 more...]]`` + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename Allocator> + std::size_t ``[link asio.reference.read_until.overload11 read_until]``( + SyncReadStream & s, + asio::basic_streambuf< Allocator > & b, + const std::string & delim); + `` [''''»''' [link asio.reference.read_until.overload11 more...]]`` + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename Allocator> + std::size_t ``[link asio.reference.read_until.overload12 read_until]``( + SyncReadStream & s, + asio::basic_streambuf< Allocator > & b, + const std::string & delim, + asio::error_code & ec); + `` [''''»''' [link asio.reference.read_until.overload12 more...]]`` + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename Allocator> + std::size_t ``[link asio.reference.read_until.overload13 read_until]``( + SyncReadStream & s, + asio::basic_streambuf< Allocator > & b, + const boost::regex & expr); + `` [''''»''' [link asio.reference.read_until.overload13 more...]]`` + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename Allocator> + std::size_t ``[link asio.reference.read_until.overload14 read_until]``( + SyncReadStream & s, + asio::basic_streambuf< Allocator > & b, + const boost::regex & expr, + asio::error_code & ec); + `` [''''»''' [link asio.reference.read_until.overload14 more...]]`` + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename Allocator, + typename MatchCondition> + std::size_t ``[link asio.reference.read_until.overload15 read_until]``( + SyncReadStream & s, + asio::basic_streambuf< Allocator > & b, + MatchCondition match_condition, + typename enable_if< is_match_condition< MatchCondition >::value >::type * = 0); + `` [''''»''' [link asio.reference.read_until.overload15 more...]]`` + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename Allocator, + typename MatchCondition> + std::size_t ``[link asio.reference.read_until.overload16 read_until]``( + SyncReadStream & s, asio::basic_streambuf< Allocator > & b, MatchCondition match_condition, asio::error_code & ec, typename enable_if< is_match_condition< MatchCondition >::value >::type * = 0); - `` [''''»''' [link asio.reference.read_until.overload8 more...]]`` + `` [''''»''' [link asio.reference.read_until.overload16 more...]]`` + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``> + std::size_t ``[link asio.reference.read_until.overload17 read_until]``( + SyncReadStream & s, + DynamicBufferSequence && buffers, + const std::string & delim); + `` [''''»''' [link asio.reference.read_until.overload17 more...]]`` + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``> + std::size_t ``[link asio.reference.read_until.overload18 read_until]``( + SyncReadStream & s, + DynamicBufferSequence && buffers, + const std::string & delim, + asio::error_code & ec); + `` [''''»''' [link asio.reference.read_until.overload18 more...]]`` [heading Requirements] @@ -91046,7 +98118,665 @@ ['Convenience header: ][^asio.hpp] -[section:overload1 read_until (1 of 8 overloads)] +[section:overload1 read_until (1 of 18 overloads)] + + +Read data into a dynamic buffer sequence until it contains a specified delimiter. + + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``> + std::size_t read_until( + SyncReadStream & s, + DynamicBufferSequence && buffers, + char delim); + + +This function is used to read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains the specified delimiter. The call will block until one of the following conditions is true: + + +* The get area of the dynamic buffer sequence contains the specified delimiter. + + +* An error occurred. + +This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the dynamic buffer sequence's get area already contains the delimiter, the function returns immediately. + + +[heading Parameters] + + +[variablelist + +[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]] + +[[buffers][The dynamic buffer sequence into which the data will be read.]] + +[[delim][The delimiter character.]] + +] + + +[heading Return Value] + +The number of bytes in the dynamic buffer sequence's get area up to and including the delimiter. + + +[heading Exceptions] + + +[variablelist + +[[asio::system_error][Thrown on failure.]] + +] + + +[heading Remarks] + +After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond the delimiter. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine. + + +[heading Example] + +To read data into a `std::string` until a newline is encountered: + + std::string data; + std::string n = asio::read_until(s, + asio::dynamic_buffer(data), '\n'); + std::string line = data.substr(0, n); + data.erase(0, n); + + +After the `read_until` operation completes successfully, the string `data` contains the delimiter: + + { 'a', 'b', ..., 'c', '\n', 'd', 'e', ... } + + +The call to `substr` then extracts the data up to and including the delimiter, so that the string `line` contains: + + { 'a', 'b', ..., 'c', '\n' } + + +After the call to `erase`, the remaining data is left in the buffer `b` as follows: + + { 'd', 'e', ... } + + +This data may be the start of a new line, to be extracted by a subsequent `read_until` operation. + + + + +[endsect] + + + +[section:overload2 read_until (2 of 18 overloads)] + + +Read data into a dynamic buffer sequence until it contains a specified delimiter. + + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``> + std::size_t read_until( + SyncReadStream & s, + DynamicBufferSequence && buffers, + char delim, + asio::error_code & ec); + + +This function is used to read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains the specified delimiter. The call will block until one of the following conditions is true: + + +* The get area of the dynamic buffer sequence contains the specified delimiter. + + +* An error occurred. + +This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the dynamic buffer sequence's get area already contains the delimiter, the function returns immediately. + + +[heading Parameters] + + +[variablelist + +[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]] + +[[buffers][The dynamic buffer sequence into which the data will be read.]] + +[[delim][The delimiter character.]] + +[[ec][Set to indicate what error occurred, if any.]] + +] + + +[heading Return Value] + +The number of bytes in the dynamic buffer sequence's get area up to and including the delimiter. Returns 0 if an error occurred. + + +[heading Remarks] + +After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond the delimiter. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine. + + + + +[endsect] + + + +[section:overload3 read_until (3 of 18 overloads)] + + +Read data into a dynamic buffer sequence until it contains a specified delimiter. + + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename Allocator> + std::size_t read_until( + SyncReadStream & s, + DynamicBufferSequence && buffers, + const std::basic_string< char, std::char_traits< char >, Allocator > & delim); + + +This function is used to read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains the specified delimiter. The call will block until one of the following conditions is true: + + +* The get area of the dynamic buffer sequence contains the specified delimiter. + + +* An error occurred. + +This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the dynamic buffer sequence's get area already contains the delimiter, the function returns immediately. + + +[heading Parameters] + + +[variablelist + +[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]] + +[[buffers][The dynamic buffer sequence into which the data will be read.]] + +[[delim][The delimiter string.]] + +] + + +[heading Return Value] + +The number of bytes in the dynamic buffer sequence's get area up to and including the delimiter. + + +[heading Remarks] + +After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond the delimiter. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine. + + +[heading Example] + +To read data into a `std::string` until a CR-LF sequence is encountered: + + std::string data; + std::string n = asio::read_until(s, + asio::dynamic_buffer(data), "\r\n"); + std::string line = data.substr(0, n); + data.erase(0, n); + + +After the `read_until` operation completes successfully, the string `data` contains the delimiter: + + { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } + + +The call to `substr` then extracts the data up to and including the delimiter, so that the string `line` contains: + + { 'a', 'b', ..., 'c', '\r', '\n' } + + +After the call to `erase`, the remaining data is left in the buffer `b` as follows: + + { 'd', 'e', ... } + + +This data may be the start of a new line, to be extracted by a subsequent `read_until` operation. + + + + +[endsect] + + + +[section:overload4 read_until (4 of 18 overloads)] + + +Read data into a dynamic buffer sequence until it contains a specified delimiter. + + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename Allocator> + std::size_t read_until( + SyncReadStream & s, + DynamicBufferSequence && buffers, + const std::basic_string< char, std::char_traits< char >, Allocator > & delim, + asio::error_code & ec); + + +This function is used to read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains the specified delimiter. The call will block until one of the following conditions is true: + + +* The get area of the dynamic buffer sequence contains the specified delimiter. + + +* An error occurred. + +This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the dynamic buffer sequence's get area already contains the delimiter, the function returns immediately. + + +[heading Parameters] + + +[variablelist + +[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]] + +[[buffers][The dynamic buffer sequence into which the data will be read.]] + +[[delim][The delimiter string.]] + +[[ec][Set to indicate what error occurred, if any.]] + +] + + +[heading Return Value] + +The number of bytes in the dynamic buffer sequence's get area up to and including the delimiter. Returns 0 if an error occurred. + + +[heading Remarks] + +After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond the delimiter. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine. + + + + +[endsect] + + + +[section:overload5 read_until (5 of 18 overloads)] + + +Read data into a dynamic buffer sequence until some part of the data it contains matches a regular expression. + + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``> + std::size_t read_until( + SyncReadStream & s, + DynamicBufferSequence && buffers, + const boost::regex & expr); + + +This function is used to read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains some data that matches a regular expression. The call will block until one of the following conditions is true: + + +* A substring of the dynamic buffer sequence's get area matches the regular expression. + + +* An error occurred. + +This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the dynamic buffer sequence's get area already contains data that matches the regular expression, the function returns immediately. + + +[heading Parameters] + + +[variablelist + +[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]] + +[[buffers][A dynamic buffer sequence into which the data will be read.]] + +[[expr][The regular expression.]] + +] + + +[heading Return Value] + +The number of bytes in the dynamic buffer sequence's get area up to and including the substring that matches the regular expression. + + +[heading Exceptions] + + +[variablelist + +[[asio::system_error][Thrown on failure.]] + +] + + +[heading Remarks] + +After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond that which matched the regular expression. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine. + + +[heading Example] + +To read data into a `std::string` until a CR-LF sequence is encountered: + + std::string data; + std::string n = asio::read_until(s, + asio::dynamic_buffer(data), boost::regex("\r\n")); + std::string line = data.substr(0, n); + data.erase(0, n); + + +After the `read_until` operation completes successfully, the string `data` contains the delimiter: + + { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } + + +The call to `substr` then extracts the data up to and including the delimiter, so that the string `line` contains: + + { 'a', 'b', ..., 'c', '\r', '\n' } + + +After the call to `erase`, the remaining data is left in the buffer `b` as follows: + + { 'd', 'e', ... } + + +This data may be the start of a new line, to be extracted by a subsequent `read_until` operation. + + + + +[endsect] + + + +[section:overload6 read_until (6 of 18 overloads)] + + +Read data into a dynamic buffer sequence until some part of the data it contains matches a regular expression. + + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``> + std::size_t read_until( + SyncReadStream & s, + DynamicBufferSequence && buffers, + const boost::regex & expr, + asio::error_code & ec); + + +This function is used to read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains some data that matches a regular expression. The call will block until one of the following conditions is true: + + +* A substring of the dynamic buffer sequence's get area matches the regular expression. + + +* An error occurred. + +This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the dynamic buffer sequence's get area already contains data that matches the regular expression, the function returns immediately. + + +[heading Parameters] + + +[variablelist + +[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]] + +[[buffers][A dynamic buffer sequence into which the data will be read.]] + +[[expr][The regular expression.]] + +[[ec][Set to indicate what error occurred, if any.]] + +] + + +[heading Return Value] + +The number of bytes in the dynamic buffer sequence's get area up to and including the substring that matches the regular expression. Returns 0 if an error occurred. + + +[heading Remarks] + +After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond that which matched the regular expression. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine. + + + + +[endsect] + + + +[section:overload7 read_until (7 of 18 overloads)] + + +Read data into a dynamic buffer sequence until a function object indicates a match. + + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename MatchCondition> + std::size_t read_until( + SyncReadStream & s, + DynamicBufferSequence && buffers, + MatchCondition match_condition, + typename enable_if< is_match_condition< MatchCondition >::value >::type * = 0); + + +This function is used to read data into the specified dynamic buffer sequence until a user-defined match condition function object, when applied to the data contained in the dynamic buffer sequence, indicates a successful match. The call will block until one of the following conditions is true: + + +* The match condition function object returns a std::pair where the second element evaluates to true. + + +* An error occurred. + +This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the match condition function object already indicates a match, the function returns immediately. + + +[heading Parameters] + + +[variablelist + +[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]] + +[[buffers][A dynamic buffer sequence into which the data will be read.]] + +[[match_condition][The function object to be called to determine whether a match exists. The signature of the function object must be: +`` + pair<iterator, bool> match_condition(iterator begin, iterator end); +`` +where `iterator` represents the type: +`` + buffers_iterator<typename DynamicBufferSequence::const_buffers_type> +`` +The iterator parameters `begin` and `end` define the range of bytes to be scanned to determine whether there is a match. The `first` member of the return value is an iterator marking one-past-the-end of the bytes that have been consumed by the match function. This iterator is used to calculate the `begin` parameter for any subsequent invocation of the match condition. The `second` member of the return value is true if a match has been found, false otherwise.]] + +] + + +[heading Return Value] + +The number of bytes in the dynamic\_buffer\_sequence's get area that have been fully consumed by the match function. + + +[heading Exceptions] + + +[variablelist + +[[asio::system_error][Thrown on failure.]] + +] + + +[heading Remarks] + +After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond that which matched the function object. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine. + +The default implementation of the `is_match_condition` type trait evaluates to true for function pointers and function objects with a `result_type` typedef. It must be specialised for other user-defined function objects. + + +[heading Examples] + +To read data into a dynamic buffer sequence until whitespace is encountered: + + typedef asio::buffers_iterator< + asio::const_buffers_1> iterator; + + std::pair<iterator, bool> + match_whitespace(iterator begin, iterator end) + { + iterator i = begin; + while (i != end) + if (std::isspace(*i++)) + return std::make_pair(i, true); + return std::make_pair(i, false); + } + ... + std::string data; + asio::read_until(s, data, match_whitespace); + + + + +To read data into a `std::string` until a matching character is found: + + class match_char + { + public: + explicit match_char(char c) : c_(c) {} + + template <typename Iterator> + std::pair<Iterator, bool> operator()( + Iterator begin, Iterator end) const + { + Iterator i = begin; + while (i != end) + if (c_ == *i++) + return std::make_pair(i, true); + return std::make_pair(i, false); + } + + private: + char c_; + }; + + namespace asio { + template <> struct is_match_condition<match_char> + : public boost::true_type {}; + } // namespace asio + ... + std::string data; + asio::read_until(s, data, match_char('a')); + + + + + +[endsect] + + + +[section:overload8 read_until (8 of 18 overloads)] + + +Read data into a dynamic buffer sequence until a function object indicates a match. + + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename MatchCondition> + std::size_t read_until( + SyncReadStream & s, + DynamicBufferSequence && buffers, + MatchCondition match_condition, + asio::error_code & ec, + typename enable_if< is_match_condition< MatchCondition >::value >::type * = 0); + + +This function is used to read data into the specified dynamic buffer sequence until a user-defined match condition function object, when applied to the data contained in the dynamic buffer sequence, indicates a successful match. The call will block until one of the following conditions is true: + + +* The match condition function object returns a std::pair where the second element evaluates to true. + + +* An error occurred. + +This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the match condition function object already indicates a match, the function returns immediately. + + +[heading Parameters] + + +[variablelist + +[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]] + +[[buffers][A dynamic buffer sequence into which the data will be read.]] + +[[match_condition][The function object to be called to determine whether a match exists. The signature of the function object must be: +`` + pair<iterator, bool> match_condition(iterator begin, iterator end); +`` +where `iterator` represents the type: +`` + buffers_iterator<DynamicBufferSequence::const_buffers_type> +`` +The iterator parameters `begin` and `end` define the range of bytes to be scanned to determine whether there is a match. The `first` member of the return value is an iterator marking one-past-the-end of the bytes that have been consumed by the match function. This iterator is used to calculate the `begin` parameter for any subsequent invocation of the match condition. The `second` member of the return value is true if a match has been found, false otherwise.]] + +[[ec][Set to indicate what error occurred, if any.]] + +] + + +[heading Return Value] + +The number of bytes in the dynamic buffer sequence's get area that have been fully consumed by the match function. Returns 0 if an error occurred. + + +[heading Remarks] + +After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond that which matched the function object. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine. + +The default implementation of the `is_match_condition` type trait evaluates to true for function pointers and function objects with a `result_type` typedef. It must be specialised for other user-defined function objects. + + + + +[endsect] + + + +[section:overload9 read_until (9 of 18 overloads)] Read data into a streambuf until it contains a specified delimiter. @@ -91141,7 +98871,7 @@ -[section:overload2 read_until (2 of 8 overloads)] +[section:overload10 read_until (10 of 18 overloads)] Read data into a streambuf until it contains a specified delimiter. @@ -91200,7 +98930,7 @@ -[section:overload3 read_until (3 of 8 overloads)] +[section:overload11 read_until (11 of 18 overloads)] Read data into a streambuf until it contains a specified delimiter. @@ -91295,7 +99025,7 @@ -[section:overload4 read_until (4 of 8 overloads)] +[section:overload12 read_until (12 of 18 overloads)] Read data into a streambuf until it contains a specified delimiter. @@ -91354,7 +99084,7 @@ -[section:overload5 read_until (5 of 8 overloads)] +[section:overload13 read_until (13 of 18 overloads)] Read data into a streambuf until some part of the data it contains matches a regular expression. @@ -91449,7 +99179,7 @@ -[section:overload6 read_until (6 of 8 overloads)] +[section:overload14 read_until (14 of 18 overloads)] Read data into a streambuf until some part of the data it contains matches a regular expression. @@ -91508,7 +99238,7 @@ -[section:overload7 read_until (7 of 8 overloads)] +[section:overload15 read_until (15 of 18 overloads)] Read data into a streambuf until a function object indicates a match. @@ -91575,7 +99305,7 @@ [heading Remarks] -After a successful read\_until operation, the streambuf may contain additional data beyond that which matched the function object. An application will typically leave that data in the streambuf for a subsequent +After a successful read\_until operation, the streambuf may contain additional data beyond that which matched the function object. An application will typically leave that data in the streambuf for a subsequent read\_until operation to examine. The default implementation of the `is_match_condition` type trait evaluates to true for function pointers and function objects with a `result_type` typedef. It must be specialised for other user-defined function objects. @@ -91641,7 +99371,7 @@ -[section:overload8 read_until (8 of 8 overloads)] +[section:overload16 read_until (16 of 18 overloads)] Read data into a streambuf until a function object indicates a match. @@ -91701,7 +99431,7 @@ [heading Remarks] -After a successful read\_until operation, the streambuf may contain additional data beyond that which matched the function object. An application will typically leave that data in the streambuf for a subsequent +After a successful read\_until operation, the streambuf may contain additional data beyond that which matched the function object. An application will typically leave that data in the streambuf for a subsequent read\_until operation to examine. The default implementation of the `is_match_condition` type trait evaluates to true for function pointers and function objects with a `result_type` typedef. It must be specialised for other user-defined function objects. @@ -91711,6 +99441,43 @@ [endsect] + +[section:overload17 read_until (17 of 18 overloads)] + + + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``> + std::size_t read_until( + SyncReadStream & s, + DynamicBufferSequence && buffers, + const std::string & delim); + + + +[endsect] + + + +[section:overload18 read_until (18 of 18 overloads)] + + + + template< + typename ``[link asio.reference.SyncReadStream SyncReadStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``> + std::size_t read_until( + SyncReadStream & s, + DynamicBufferSequence && buffers, + const std::string & delim, + asio::error_code & ec); + + + +[endsect] + + [endsect] [section:seq_packet_socket_service seq_packet_socket_service] @@ -91976,7 +99743,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_connect( implementation_type & impl, const endpoint_type & peer_endpoint, - ConnectHandler handler); + ConnectHandler && handler); @@ -91998,7 +99765,7 @@ const MutableBufferSequence & buffers, socket_base::message_flags in_flags, socket_base::message_flags & out_flags, - ReadHandler handler); + ReadHandler && handler); @@ -92019,7 +99786,7 @@ implementation_type & impl, const ConstBufferSequence & buffers, socket_base::message_flags flags, - WriteHandler handler); + WriteHandler && handler); @@ -92038,7 +99805,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( implementation_type & impl, socket_base::wait_type w, - WaitHandler handler); + WaitHandler && handler); @@ -93774,7 +101541,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_read_some( implementation_type & impl, const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); @@ -93794,7 +101561,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_write_some( implementation_type & impl, const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); @@ -94462,7 +102229,7 @@ typename ``[link asio.reference.SignalHandler SignalHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( implementation_type & impl, - SignalHandler handler); + SignalHandler && handler); @@ -94684,6 +102451,11 @@ ] [ + [[link asio.reference.socket_acceptor_service.async_wait [*async_wait]]] + [Asynchronously wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. ] + ] + + [ [[link asio.reference.socket_acceptor_service.bind [*bind]]] [Bind the socket acceptor to the specified local endpoint. ] ] @@ -94787,6 +102559,11 @@ [Construct a new socket acceptor service for the specified io_service. ] ] + [ + [[link asio.reference.socket_acceptor_service.wait [*wait]]] + [Wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. ] + ] + ] [heading Data Members] @@ -94861,7 +102638,7 @@ implementation_type & impl, basic_socket< Protocol1, SocketService > & peer, endpoint_type * peer_endpoint, - AcceptHandler handler, + AcceptHandler && handler, typename enable_if< is_convertible< Protocol, Protocol1 >::value >::type * = 0); @@ -94870,6 +102647,25 @@ +[section:async_wait socket_acceptor_service::async_wait] + +[indexterm2 async_wait..socket_acceptor_service] +Asynchronously wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. + + + template< + typename ``[link asio.reference.WaitHandler WaitHandler]``> + ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( + implementation_type & impl, + socket_base::wait_type w, + WaitHandler && handler); + + + +[endsect] + + + [section:bind socket_acceptor_service::bind] [indexterm2 bind..socket_acceptor_service] @@ -95376,6 +103172,23 @@ +[section:wait socket_acceptor_service::wait] + +[indexterm2 wait..socket_acceptor_service] +Wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. + + + asio::error_code wait( + implementation_type & impl, + socket_base::wait_type w, + asio::error_code & ec); + + + +[endsect] + + + [endsect] [section:socket_base socket_base] @@ -96341,60 +104154,67 @@ template< - typename ``[link asio.reference.Handler Handler]``, typename Function> void ``[link asio.reference.spawn.overload1 spawn]``( - Handler handler, - Function function, - const boost::coroutines::attributes & attributes = boost::coroutines::attributes(), - typename enable_if<!is_executor< typename decay< Handler >::type >::value &&!is_convertible< Handler &, execution_context & >::value >::type * = 0); + Function && function, + const boost::coroutines::attributes & attributes = boost::coroutines::attributes()); `` [''''»''' [link asio.reference.spawn.overload1 more...]]`` template< typename ``[link asio.reference.Handler Handler]``, typename Function> void ``[link asio.reference.spawn.overload2 spawn]``( - basic_yield_context< Handler > ctx, - Function function, - const boost::coroutines::attributes & attributes = boost::coroutines::attributes()); + Handler && handler, + Function && function, + const boost::coroutines::attributes & attributes = boost::coroutines::attributes(), + typename enable_if<!is_executor< typename decay< Handler >::type >::value &&!is_convertible< Handler &, execution_context & >::value >::type * = 0); `` [''''»''' [link asio.reference.spawn.overload2 more...]]`` template< - typename Function, - typename ``[link asio.reference.Executor Executor]``> + typename ``[link asio.reference.Handler Handler]``, + typename Function> void ``[link asio.reference.spawn.overload3 spawn]``( - const Executor & ex, - Function function, - const boost::coroutines::attributes & attributes = boost::coroutines::attributes(), - typename enable_if< is_executor< Executor >::value >::type * = 0); + basic_yield_context< Handler > ctx, + Function && function, + const boost::coroutines::attributes & attributes = boost::coroutines::attributes()); `` [''''»''' [link asio.reference.spawn.overload3 more...]]`` template< typename Function, typename ``[link asio.reference.Executor Executor]``> void ``[link asio.reference.spawn.overload4 spawn]``( - const strand< Executor > & ex, - Function function, - const boost::coroutines::attributes & attributes = boost::coroutines::attributes()); + const Executor & ex, + Function && function, + const boost::coroutines::attributes & attributes = boost::coroutines::attributes(), + typename enable_if< is_executor< Executor >::value >::type * = 0); `` [''''»''' [link asio.reference.spawn.overload4 more...]]`` template< - typename Function> + typename Function, + typename ``[link asio.reference.Executor Executor]``> void ``[link asio.reference.spawn.overload5 spawn]``( - const asio::io_service::strand & s, - Function function, + const strand< Executor > & ex, + Function && function, const boost::coroutines::attributes & attributes = boost::coroutines::attributes()); `` [''''»''' [link asio.reference.spawn.overload5 more...]]`` template< + typename Function> + void ``[link asio.reference.spawn.overload6 spawn]``( + const asio::io_service::strand & s, + Function && function, + const boost::coroutines::attributes & attributes = boost::coroutines::attributes()); + `` [''''»''' [link asio.reference.spawn.overload6 more...]]`` + + template< typename Function, typename ExecutionContext> - void ``[link asio.reference.spawn.overload6 spawn]``( + void ``[link asio.reference.spawn.overload7 spawn]``( ExecutionContext & ctx, - Function function, + Function && function, const boost::coroutines::attributes & attributes = boost::coroutines::attributes(), typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type * = 0); - `` [''''»''' [link asio.reference.spawn.overload6 more...]]`` + `` [''''»''' [link asio.reference.spawn.overload7 more...]]`` The `spawn()` function is a high-level wrapper over the Boost.Coroutine library. This function enables programs to implement asynchronous logic in a synchronous manner, as illustrated by the following example: @@ -96435,7 +104255,45 @@ ['Convenience header: ]None -[section:overload1 spawn (1 of 6 overloads)] +[section:overload1 spawn (1 of 7 overloads)] + + +Start a new stackful coroutine, calling the specified handler when it completes. + + + template< + typename Function> + void spawn( + Function && function, + const boost::coroutines::attributes & attributes = boost::coroutines::attributes()); + + +This function is used to launch a new coroutine. + + +[heading Parameters] + + +[variablelist + +[[function][The coroutine function. The function must have the signature: +`` + void function(basic_yield_context<Handler> yield); +`` +]] + +[[attributes][Boost.Coroutine attributes used to customise the coroutine. ]] + +] + + + + +[endsect] + + + +[section:overload2 spawn (2 of 7 overloads)] Start a new stackful coroutine, calling the specified handler when it completes. @@ -96445,8 +104303,8 @@ typename ``[link asio.reference.Handler Handler]``, typename Function> void spawn( - Handler handler, - Function function, + Handler && handler, + Function && function, const boost::coroutines::attributes & attributes = boost::coroutines::attributes(), typename enable_if<!is_executor< typename decay< Handler >::type >::value &&!is_convertible< Handler &, execution_context & >::value >::type * = 0); @@ -96482,7 +104340,7 @@ -[section:overload2 spawn (2 of 6 overloads)] +[section:overload3 spawn (3 of 7 overloads)] Start a new stackful coroutine, inheriting the execution context of another. @@ -96493,7 +104351,7 @@ typename Function> void spawn( basic_yield_context< Handler > ctx, - Function function, + Function && function, const boost::coroutines::attributes & attributes = boost::coroutines::attributes()); @@ -96524,7 +104382,7 @@ -[section:overload3 spawn (3 of 6 overloads)] +[section:overload4 spawn (4 of 7 overloads)] Start a new stackful coroutine that executes on a given executor. @@ -96535,7 +104393,7 @@ typename ``[link asio.reference.Executor Executor]``> void spawn( const Executor & ex, - Function function, + Function && function, const boost::coroutines::attributes & attributes = boost::coroutines::attributes(), typename enable_if< is_executor< Executor >::value >::type * = 0); @@ -96567,7 +104425,7 @@ -[section:overload4 spawn (4 of 6 overloads)] +[section:overload5 spawn (5 of 7 overloads)] Start a new stackful coroutine that executes on a given strand. @@ -96578,7 +104436,7 @@ typename ``[link asio.reference.Executor Executor]``> void spawn( const strand< Executor > & ex, - Function function, + Function && function, const boost::coroutines::attributes & attributes = boost::coroutines::attributes()); @@ -96609,7 +104467,7 @@ -[section:overload5 spawn (5 of 6 overloads)] +[section:overload6 spawn (6 of 7 overloads)] Start a new stackful coroutine that executes in the context of a strand. @@ -96619,7 +104477,7 @@ typename Function> void spawn( const asio::io_service::strand & s, - Function function, + Function && function, const boost::coroutines::attributes & attributes = boost::coroutines::attributes()); @@ -96650,7 +104508,7 @@ -[section:overload6 spawn (6 of 6 overloads)] +[section:overload7 spawn (7 of 7 overloads)] Start a new stackful coroutine that executes on a given execution context. @@ -96661,7 +104519,7 @@ typename ExecutionContext> void spawn( ExecutionContext & ctx, - Function function, + Function && function, const boost::coroutines::attributes & attributes = boost::coroutines::attributes(), typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type * = 0); @@ -96902,6 +104760,16 @@ ] [ + [[link asio.reference.ssl__context.no_tlsv1_1 [*no_tlsv1_1]]] + [Disable TLS v1.1. ] + ] + + [ + [[link asio.reference.ssl__context.no_tlsv1_2 [*no_tlsv1_2]]] + [Disable TLS v1.2. ] + ] + + [ [[link asio.reference.ssl__context.single_dh_use [*single_dh_use]]] [Always create a new key when using tmp_dh parameters. ] ] @@ -97648,6 +105516,34 @@ +[section:no_tlsv1_1 ssl::context::no_tlsv1_1] + +[indexterm2 no_tlsv1_1..ssl::context] +Disable TLS v1.1. + + + static const long no_tlsv1_1 = implementation_defined; + + + +[endsect] + + + +[section:no_tlsv1_2 ssl::context::no_tlsv1_2] + +[indexterm2 no_tlsv1_2..ssl::context] +Disable TLS v1.2. + + + static const long no_tlsv1_2 = implementation_defined; + + + +[endsect] + + + [section:operator_eq_ ssl::context::operator=] [indexterm2 operator=..ssl::context] @@ -99498,6 +107394,16 @@ ] [ + [[link asio.reference.ssl__context_base.no_tlsv1_1 [*no_tlsv1_1]]] + [Disable TLS v1.1. ] + ] + + [ + [[link asio.reference.ssl__context_base.no_tlsv1_2 [*no_tlsv1_2]]] + [Disable TLS v1.2. ] + ] + + [ [[link asio.reference.ssl__context_base.single_dh_use [*single_dh_use]]] [Always create a new key when using tmp_dh parameters. ] ] @@ -99741,6 +107647,34 @@ +[section:no_tlsv1_1 ssl::context_base::no_tlsv1_1] + +[indexterm2 no_tlsv1_1..ssl::context_base] +Disable TLS v1.1. + + + static const long no_tlsv1_1 = implementation_defined; + + + +[endsect] + + + +[section:no_tlsv1_2 ssl::context_base::no_tlsv1_2] + +[indexterm2 no_tlsv1_2..ssl::context_base] +Disable TLS v1.2. + + + static const long no_tlsv1_2 = implementation_defined; + + + +[endsect] + + + [section:options ssl::context_base::options] [indexterm2 options..ssl::context_base] @@ -100141,7 +108075,7 @@ typename ``[link asio.reference.HandshakeHandler HandshakeHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.ssl__stream.async_handshake.overload1 async_handshake]``( handshake_type type, - HandshakeHandler handler); + HandshakeHandler && handler); `` [''''»''' [link asio.reference.ssl__stream.async_handshake.overload1 more...]]`` template< @@ -100150,7 +108084,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` ``[link asio.reference.ssl__stream.async_handshake.overload2 async_handshake]``( handshake_type type, const ConstBufferSequence & buffers, - BufferedHandshakeHandler handler); + BufferedHandshakeHandler && handler); `` [''''»''' [link asio.reference.ssl__stream.async_handshake.overload2 more...]]`` @@ -100164,7 +108098,7 @@ typename ``[link asio.reference.HandshakeHandler HandshakeHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_handshake( handshake_type type, - HandshakeHandler handler); + HandshakeHandler && handler); This function is used to asynchronously perform an SSL handshake on the stream. This function call always returns immediately. @@ -100206,7 +108140,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_handshake( handshake_type type, const ConstBufferSequence & buffers, - BufferedHandshakeHandler handler); + BufferedHandshakeHandler && handler); This function is used to asynchronously perform an SSL handshake on the stream. This function call always returns immediately. @@ -100252,7 +108186,7 @@ typename ``[link asio.reference.ReadHandler ReadHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_read_some( const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously read one or more bytes of data from the stream. The function call always returns immediately. @@ -100297,7 +108231,7 @@ template< typename ``[link asio.reference.ShutdownHandler ShutdownHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_shutdown( - ShutdownHandler handler); + ShutdownHandler && handler); This function is used to asynchronously shut down SSL on the stream. This function call always returns immediately. @@ -100336,7 +108270,7 @@ typename ``[link asio.reference.WriteHandler WriteHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_write_some( const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); This function is used to asynchronously write one or more bytes of data to the stream. The function call always returns immediately. @@ -101345,7 +109279,7 @@ template< typename Arg> stream( - Arg & arg, + Arg && arg, context & ctx); @@ -102274,7 +110208,7 @@ typename Function, typename Allocator> void defer( - Function f, + Function && f, const Allocator & a); @@ -102313,7 +110247,7 @@ typename Function, typename Allocator> void dispatch( - Function f, + Function && f, const Allocator & a); @@ -102575,7 +110509,7 @@ typename Function, typename Allocator> void post( - Function f, + Function && f, const Allocator & a); @@ -103058,7 +110992,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_connect( implementation_type & impl, const endpoint_type & peer_endpoint, - ConnectHandler handler); + ConnectHandler && handler); @@ -103079,7 +111013,7 @@ implementation_type & impl, const MutableBufferSequence & buffers, socket_base::message_flags flags, - ReadHandler handler); + ReadHandler && handler); @@ -103100,7 +111034,7 @@ implementation_type & impl, const ConstBufferSequence & buffers, socket_base::message_flags flags, - WriteHandler handler); + WriteHandler && handler); @@ -103119,7 +111053,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( implementation_type & impl, socket_base::wait_type w, - WaitHandler handler); + WaitHandler && handler); @@ -103797,6 +111731,11 @@ ] [ + [[link asio.reference.basic_streambuf.capacity [*capacity]]] + [Get the current capacity of the basic_streambuf. ] + ] + + [ [[link asio.reference.basic_streambuf.commit [*commit]]] [Move characters from the output sequence to the input sequence. ] ] @@ -104231,7 +112170,7 @@ typename Function, typename Allocator> void defer( - Function f, + Function && f, const Allocator & a); @@ -104270,7 +112209,7 @@ typename Function, typename Allocator> void dispatch( - Function f, + Function && f, const Allocator & a); @@ -104389,7 +112328,7 @@ typename Function, typename Allocator> void post( - Function f, + Function && f, const Allocator & a); @@ -104500,7 +112439,7 @@ [ [[link asio.reference.system_executor__context_impl.add_service [*add_service]]] - [Add a service object to the execution_context. ] + [(Deprecated: Use make_service().) Add a service object to the execution_context. ] ] [ @@ -104509,6 +112448,11 @@ ] [ + [[link asio.reference.system_executor__context_impl.make_service [*make_service]]] + [Creates a service object and adds it to the execution_context. ] + ] + + [ [[link asio.reference.system_executor__context_impl.use_service [*use_service]]] [Obtain the service object corresponding to the given type. ] ] @@ -104528,7 +112472,7 @@ ['Inherited from execution_context.] [indexterm2 add_service..system_executor::context_impl] -Add a service object to the [link asio.reference.execution_context `execution_context`]. +(Deprecated: Use `make_service()`.) Add a service object to the [link asio.reference.execution_context `execution_context`]. template< @@ -104703,6 +112647,60 @@ +[section:make_service system_executor::context_impl::make_service] + + +['Inherited from execution_context.] + +[indexterm2 make_service..system_executor::context_impl] +Creates a service object and adds it to the [link asio.reference.execution_context `execution_context`]. + + + template< + typename ``[link asio.reference.Service Service]``, + typename... Args> + friend Service & make_service( + execution_context & e, + Args &&... args); + + +This function is used to add a service to the [link asio.reference.execution_context `execution_context`]. + + +[heading Parameters] + + +[variablelist + +[[e][The [link asio.reference.execution_context `execution_context`] object that owns the service.]] + +[[args][Zero or more arguments to be passed to the service constructor.]] + +] + + +[heading Exceptions] + + +[variablelist + +[[asio::service_already_exists][Thrown if a service of the given type is already present in the [link asio.reference.execution_context `execution_context`]. ]] + +] + + + +[heading Requirements] + +['Header: ][^asio/system_executor.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + [section:notify_fork system_executor::context_impl::notify_fork] @@ -104834,7 +112832,7 @@ template< typename ``[link asio.reference.Service Service]``> friend Service & ``[link asio.reference.system_executor__context_impl.use_service.overload2 use_service]``( - io_service & i); + io_service & ios); `` [''''»''' [link asio.reference.system_executor__context_impl.use_service.overload2 more...]]`` @@ -104895,7 +112893,7 @@ template< typename ``[link asio.reference.Service Service]``> friend Service & use_service( - io_service & i); + io_service & ios); This function is used to locate a service object that corresponds to the given service type. If there is no existing implementation of the service, then the [link asio.reference.io_service `io_service`] will create a new instance of the service. @@ -104906,7 +112904,7 @@ [variablelist -[[i][The [link asio.reference.io_service `io_service`] object that owns the service.]] +[[ios][The [link asio.reference.io_service `io_service`] object that owns the service.]] ] @@ -105517,7 +113515,7 @@ [ [[link asio.reference.thread_pool.add_service [*add_service]]] - [Add a service object to the execution_context. ] + [(Deprecated: Use make_service().) Add a service object to the execution_context. ] ] [ @@ -105526,6 +113524,11 @@ ] [ + [[link asio.reference.thread_pool.make_service [*make_service]]] + [Creates a service object and adds it to the execution_context. ] + ] + + [ [[link asio.reference.thread_pool.use_service [*use_service]]] [Obtain the service object corresponding to the given type. ] ] @@ -105547,7 +113550,7 @@ ['Inherited from execution_context.] [indexterm2 add_service..thread_pool] -Add a service object to the [link asio.reference.execution_context `execution_context`]. +(Deprecated: Use `make_service()`.) Add a service object to the [link asio.reference.execution_context `execution_context`]. template< @@ -105740,6 +113743,60 @@ +[section:make_service thread_pool::make_service] + + +['Inherited from execution_context.] + +[indexterm2 make_service..thread_pool] +Creates a service object and adds it to the [link asio.reference.execution_context `execution_context`]. + + + template< + typename ``[link asio.reference.Service Service]``, + typename... Args> + friend Service & make_service( + execution_context & e, + Args &&... args); + + +This function is used to add a service to the [link asio.reference.execution_context `execution_context`]. + + +[heading Parameters] + + +[variablelist + +[[e][The [link asio.reference.execution_context `execution_context`] object that owns the service.]] + +[[args][Zero or more arguments to be passed to the service constructor.]] + +] + + +[heading Exceptions] + + +[variablelist + +[[asio::service_already_exists][Thrown if a service of the given type is already present in the [link asio.reference.execution_context `execution_context`]. ]] + +] + + + +[heading Requirements] + +['Header: ][^asio/thread_pool.hpp] + +['Convenience header: ][^asio.hpp] + + +[endsect] + + + [section:notify_fork thread_pool::notify_fork] @@ -105911,7 +113968,7 @@ template< typename ``[link asio.reference.Service Service]``> friend Service & ``[link asio.reference.thread_pool.use_service.overload2 use_service]``( - io_service & i); + io_service & ios); `` [''''»''' [link asio.reference.thread_pool.use_service.overload2 more...]]`` @@ -105972,7 +114029,7 @@ template< typename ``[link asio.reference.Service Service]``> friend Service & use_service( - io_service & i); + io_service & ios); This function is used to locate a service object that corresponds to the given service type. If there is no existing implementation of the service, then the [link asio.reference.io_service `io_service`] will create a new instance of the service. @@ -105983,7 +114040,7 @@ [variablelist -[[i][The [link asio.reference.io_service `io_service`] object that owns the service.]] +[[ios][The [link asio.reference.io_service `io_service`] object that owns the service.]] ] @@ -106127,7 +114184,7 @@ typename Function, typename Allocator> void defer( - Function f, + Function && f, const Allocator & a); @@ -106168,7 +114225,7 @@ typename Function, typename Allocator> void dispatch( - Function f, + Function && f, const Allocator & a); @@ -106287,7 +114344,7 @@ typename Function, typename Allocator> void post( - Function f, + Function && f, const Allocator & a); @@ -106995,7 +115052,7 @@ [variablelist -[[i][The [link asio.reference.io_service `io_service`] object that owns the service.]] +[[ios][The [link asio.reference.io_service `io_service`] object that owns the service.]] ] @@ -107291,7 +115348,7 @@ typename ``[link asio.reference.WaitHandler WaitHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( implementation_type & impl, - WaitHandler handler); + WaitHandler && handler); @@ -108992,7 +117049,7 @@ template< typename ``[link asio.reference.WaitHandler WaitHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( - WaitHandler handler); + WaitHandler && handler); This function is be used to initiate an asynchronous wait against the object handle. It always returns immediately. @@ -110207,7 +118264,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_read_some_at( uint64_t offset, const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously read data from the random-access handle. The function call always returns immediately. @@ -110267,7 +118324,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_write_some_at( uint64_t offset, const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); This function is used to asynchronously write data to the random-access handle. The function call always returns immediately. @@ -111698,7 +119755,7 @@ typename ``[link asio.reference.ReadHandler ReadHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_read_some( const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); This function is used to asynchronously read data from the stream handle. The function call always returns immediately. @@ -111755,7 +119812,7 @@ typename ``[link asio.reference.WriteHandler WriteHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_write_some( const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); This function is used to asynchronously write data to the stream handle. The function call always returns immediately. @@ -113240,7 +121297,7 @@ typename ``[link asio.reference.WaitHandler WaitHandler]``> ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_wait( implementation_type & impl, - WaitHandler handler); + WaitHandler && handler); @@ -113619,7 +121676,7 @@ typename ``[link asio.reference.Handler Handler]``> explicit ``[link asio.reference.windows__overlapped_ptr.overlapped_ptr.overload2 overlapped_ptr]``( asio::io_service & io_service, - Handler handler); + Handler && handler); `` [''''»''' [link asio.reference.windows__overlapped_ptr.overlapped_ptr.overload2 more...]]`` @@ -113647,7 +121704,7 @@ typename ``[link asio.reference.Handler Handler]``> overlapped_ptr( asio::io_service & io_service, - Handler handler); + Handler && handler); @@ -113687,7 +121744,7 @@ typename ``[link asio.reference.Handler Handler]``> void ``[link asio.reference.windows__overlapped_ptr.reset.overload2 reset]``( asio::io_service & io_service, - Handler handler); + Handler && handler); `` [''''»''' [link asio.reference.windows__overlapped_ptr.reset.overload2 more...]]`` @@ -113715,7 +121772,7 @@ typename ``[link asio.reference.Handler Handler]``> void reset( asio::io_service & io_service, - Handler handler); + Handler && handler); @@ -114071,7 +122128,7 @@ implementation_type & impl, uint64_t offset, const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); @@ -114092,7 +122149,7 @@ implementation_type & impl, uint64_t offset, const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); @@ -114685,7 +122742,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_read_some( implementation_type & impl, const MutableBufferSequence & buffers, - ReadHandler handler); + ReadHandler && handler); @@ -114705,7 +122762,7 @@ ``[link asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]`` async_write_some( implementation_type & impl, const ConstBufferSequence & buffers, - WriteHandler handler); + WriteHandler && handler); @@ -114977,7 +123034,7 @@ typename T> executor_wrapper< typename decay< T >::type, Executor > ``[link asio.reference.wrap.overload1 wrap]``( const Executor & ex, - T t, + T && t, typename enable_if< is_executor< Executor >::value >::type * = 0); `` [''''»''' [link asio.reference.wrap.overload1 more...]]`` @@ -114986,7 +123043,7 @@ typename T> executor_wrapper< typename decay< T >::type, typename ExecutionContext::executor_type > ``[link asio.reference.wrap.overload2 wrap]``( ExecutionContext & ctx, - T t, + T && t, typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type * = 0); `` [''''»''' [link asio.reference.wrap.overload2 more...]]`` @@ -115008,7 +123065,7 @@ typename T> executor_wrapper< typename decay< T >::type, Executor > wrap( const Executor & ex, - T t, + T && t, typename enable_if< is_executor< Executor >::value >::type * = 0); @@ -115028,7 +123085,7 @@ typename T> executor_wrapper< typename decay< T >::type, typename ExecutionContext::executor_type > wrap( ExecutionContext & ctx, - T t, + T && t, typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type * = 0); @@ -115049,7 +123106,8 @@ typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``> std::size_t ``[link asio.reference.write.overload1 write]``( SyncWriteStream & s, - const ConstBufferSequence & buffers); + const ConstBufferSequence & buffers, + typename enable_if< is_const_buffer_sequence< ConstBufferSequence >::value >::type * = 0); `` [''''»''' [link asio.reference.write.overload1 more...]]`` template< @@ -115058,7 +123116,8 @@ std::size_t ``[link asio.reference.write.overload2 write]``( SyncWriteStream & s, const ConstBufferSequence & buffers, - asio::error_code & ec); + asio::error_code & ec, + typename enable_if< is_const_buffer_sequence< ConstBufferSequence >::value >::type * = 0); `` [''''»''' [link asio.reference.write.overload2 more...]]`` template< @@ -115068,7 +123127,8 @@ std::size_t ``[link asio.reference.write.overload3 write]``( SyncWriteStream & s, const ConstBufferSequence & buffers, - CompletionCondition completion_condition); + CompletionCondition completion_condition, + typename enable_if< is_const_buffer_sequence< ConstBufferSequence >::value >::type * = 0); `` [''''»''' [link asio.reference.write.overload3 more...]]`` template< @@ -115079,46 +123139,89 @@ SyncWriteStream & s, const ConstBufferSequence & buffers, CompletionCondition completion_condition, - asio::error_code & ec); + asio::error_code & ec, + typename enable_if< is_const_buffer_sequence< ConstBufferSequence >::value >::type * = 0); `` [''''»''' [link asio.reference.write.overload4 more...]]`` template< typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``, - typename Allocator> + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``> std::size_t ``[link asio.reference.write.overload5 write]``( SyncWriteStream & s, - basic_streambuf< Allocator > & b); + DynamicBufferSequence && buffers, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); `` [''''»''' [link asio.reference.write.overload5 more...]]`` template< typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``, - typename Allocator> + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``> std::size_t ``[link asio.reference.write.overload6 write]``( SyncWriteStream & s, - basic_streambuf< Allocator > & b, - asio::error_code & ec); + DynamicBufferSequence && buffers, + asio::error_code & ec, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); `` [''''»''' [link asio.reference.write.overload6 more...]]`` template< typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``, - typename Allocator, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, typename CompletionCondition> std::size_t ``[link asio.reference.write.overload7 write]``( SyncWriteStream & s, - basic_streambuf< Allocator > & b, - CompletionCondition completion_condition); + DynamicBufferSequence && buffers, + CompletionCondition completion_condition, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); `` [''''»''' [link asio.reference.write.overload7 more...]]`` template< typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename CompletionCondition> + std::size_t ``[link asio.reference.write.overload8 write]``( + SyncWriteStream & s, + DynamicBufferSequence && buffers, + CompletionCondition completion_condition, + asio::error_code & ec, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); + `` [''''»''' [link asio.reference.write.overload8 more...]]`` + + template< + typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``, + typename Allocator> + std::size_t ``[link asio.reference.write.overload9 write]``( + SyncWriteStream & s, + basic_streambuf< Allocator > & b); + `` [''''»''' [link asio.reference.write.overload9 more...]]`` + + template< + typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``, + typename Allocator> + std::size_t ``[link asio.reference.write.overload10 write]``( + SyncWriteStream & s, + basic_streambuf< Allocator > & b, + asio::error_code & ec); + `` [''''»''' [link asio.reference.write.overload10 more...]]`` + + template< + typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``, typename Allocator, typename CompletionCondition> - std::size_t ``[link asio.reference.write.overload8 write]``( + std::size_t ``[link asio.reference.write.overload11 write]``( + SyncWriteStream & s, + basic_streambuf< Allocator > & b, + CompletionCondition completion_condition); + `` [''''»''' [link asio.reference.write.overload11 more...]]`` + + template< + typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``, + typename Allocator, + typename CompletionCondition> + std::size_t ``[link asio.reference.write.overload12 write]``( SyncWriteStream & s, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, asio::error_code & ec); - `` [''''»''' [link asio.reference.write.overload8 more...]]`` + `` [''''»''' [link asio.reference.write.overload12 more...]]`` [heading Requirements] @@ -115127,7 +123230,7 @@ ['Convenience header: ][^asio.hpp] -[section:overload1 write (1 of 8 overloads)] +[section:overload1 write (1 of 12 overloads)] Write all of the supplied data to a stream before returning. @@ -115138,7 +123241,8 @@ typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``> std::size_t write( SyncWriteStream & s, - const ConstBufferSequence & buffers); + const ConstBufferSequence & buffers, + typename enable_if< is_const_buffer_sequence< ConstBufferSequence >::value >::type * = 0); 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: @@ -115207,7 +123311,7 @@ -[section:overload2 write (2 of 8 overloads)] +[section:overload2 write (2 of 12 overloads)] Write all of the supplied data to a stream before returning. @@ -115219,7 +123323,8 @@ std::size_t write( SyncWriteStream & s, const ConstBufferSequence & buffers, - asio::error_code & ec); + asio::error_code & ec, + typename enable_if< is_const_buffer_sequence< ConstBufferSequence >::value >::type * = 0); 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: @@ -115280,7 +123385,7 @@ -[section:overload3 write (3 of 8 overloads)] +[section:overload3 write (3 of 12 overloads)] Write a certain amount of data to a stream before returning. @@ -115293,7 +123398,8 @@ 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); 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: @@ -115363,7 +123469,7 @@ -[section:overload4 write (4 of 8 overloads)] +[section:overload4 write (4 of 12 overloads)] Write a certain amount of data to a stream before returning. @@ -115377,7 +123483,8 @@ SyncWriteStream & s, const ConstBufferSequence & buffers, CompletionCondition completion_condition, - asio::error_code & ec); + asio::error_code & ec, + typename enable_if< is_const_buffer_sequence< ConstBufferSequence >::value >::type * = 0); 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: @@ -115428,7 +123535,281 @@ -[section:overload5 write (5 of 8 overloads)] +[section:overload5 write (5 of 12 overloads)] + + +Write all of the supplied data to a stream before returning. + + + template< + typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``> + std::size_t write( + SyncWriteStream & s, + DynamicBufferSequence && buffers, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); + + +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: + + +* All of the data in the supplied dynamic buffer sequence has been written. + + +* An error occurred. + +This operation is implemented in terms of zero or more calls to the stream's write\_some function. + + +[heading Parameters] + + +[variablelist + +[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]] + +[[buffers][The dynamic buffer sequence from which data will be written. Successfully written data is automatically consumed from the buffers.]] + +] + + +[heading Return Value] + +The number of bytes transferred. + + +[heading Exceptions] + + +[variablelist + +[[asio::system_error][Thrown on failure.]] + +] + + +[heading Remarks] + +This overload is equivalent to calling: + + asio::write( + s, buffers, + asio::transfer_all()); + + + + + + + +[endsect] + + + +[section:overload6 write (6 of 12 overloads)] + + +Write all of the supplied data to a stream before returning. + + + template< + typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``> + std::size_t write( + SyncWriteStream & s, + DynamicBufferSequence && buffers, + asio::error_code & ec, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); + + +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: + + +* All of the data in the supplied dynamic buffer sequence has been written. + + +* An error occurred. + +This operation is implemented in terms of zero or more calls to the stream's write\_some function. + + +[heading Parameters] + + +[variablelist + +[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]] + +[[buffers][The dynamic buffer sequence from which data will be written. Successfully written data is automatically consumed from the buffers.]] + +[[ec][Set to indicate what error occurred, if any.]] + +] + + +[heading Return Value] + +The number of bytes transferred. + + +[heading Remarks] + +This overload is equivalent to calling: + + asio::write( + s, buffers, + asio::transfer_all(), ec); + + + + + + + +[endsect] + + + +[section:overload7 write (7 of 12 overloads)] + + +Write a certain amount of data to a stream before returning. + + + template< + typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename CompletionCondition> + std::size_t write( + SyncWriteStream & s, + DynamicBufferSequence && buffers, + CompletionCondition completion_condition, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); + + +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: + + +* All of the data in the supplied dynamic buffer sequence has been written. + + +* 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. + + +[heading Parameters] + + +[variablelist + +[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]] + +[[buffers][The dynamic buffer sequence from which data will be written. Successfully written data is automatically consumed from the buffers.]] + +[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: +`` + 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 + ); +`` +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.]] + +] + + +[heading Return Value] + +The number of bytes transferred. + + +[heading Exceptions] + + +[variablelist + +[[asio::system_error][Thrown on failure. ]] + +] + + + + +[endsect] + + + +[section:overload8 write (8 of 12 overloads)] + + +Write a certain amount of data to a stream before returning. + + + template< + typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``, + typename ``[link asio.reference.DynamicBufferSequence DynamicBufferSequence]``, + typename CompletionCondition> + std::size_t write( + SyncWriteStream & s, + DynamicBufferSequence && buffers, + CompletionCondition completion_condition, + asio::error_code & ec, + typename enable_if< is_dynamic_buffer_sequence< DynamicBufferSequence >::value >::type * = 0); + + +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: + + +* All of the data in the supplied dynamic buffer sequence has been written. + + +* 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. + + +[heading Parameters] + + +[variablelist + +[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]] + +[[buffers][The dynamic buffer sequence from which data will be written. Successfully written data is automatically consumed from the buffers.]] + +[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: +`` + 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 + ); +`` +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.]] + +[[ec][Set to indicate what error occurred, if any.]] + +] + + +[heading Return Value] + +The number of bytes written. If an error occurs, returns the total number of bytes successfully transferred prior to the error. + + + + +[endsect] + + + +[section:overload9 write (9 of 12 overloads)] Write all of the supplied data to a stream before returning. @@ -115498,7 +123879,7 @@ -[section:overload6 write (6 of 8 overloads)] +[section:overload10 write (10 of 12 overloads)] Write all of the supplied data to a stream before returning. @@ -115561,7 +123942,7 @@ -[section:overload7 write (7 of 8 overloads)] +[section:overload11 write (11 of 12 overloads)] Write a certain amount of data to a stream before returning. @@ -115633,7 +124014,7 @@ -[section:overload8 write (8 of 8 overloads)] +[section:overload12 write (12 of 12 overloads)] Write a certain amount of data to a stream before returning.