Imported Upstream version 1.72.0

[platform/upstream/boost.git] / libs / asio / doc / reference.qbk

diff --git a/libs/asio/doc/reference.qbk b/libs/asio/doc/reference.qbk
index 97b6c2b..c050a5d 100644 (file)
--- a/libs/asio/doc/reference.qbk
+++ b/libs/asio/doc/reference.qbk
@@ -683,7 +683,7 @@ Launch an asynchronous operation with a stateful implementation.
       typename... IoObjectsOrExecutors>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_compose(
       Implementation && implementation,
-      BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token,
+      CompletionToken & token,
       IoObjectsOrExecutors &&... io_objects_or_executors);
 
 
@@ -788,11 +788,11 @@ Asynchronously establishes a socket connection by trying each endpoint in a sequ
       typename ``[link boost_asio.reference.Protocol Protocol]``,
       typename ``[link boost_asio.reference.Executor1 Executor]``,
       typename ``[link boost_asio.reference.EndpointSequence EndpointSequence]``,
-      typename ``[link boost_asio.reference.RangeConnectHandler RangeConnectHandler]``>
+      typename ``[link boost_asio.reference.RangeConnectHandler RangeConnectHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_connect.overload1 async_connect]``(
       basic_socket< Protocol, Executor > & s,
       const EndpointSequence & endpoints,
-      RangeConnectHandler && handler,
+      RangeConnectHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_endpoint_sequence< EndpointSequence >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_connect.overload1 more...]]``
 
@@ -802,11 +802,11 @@ Asynchronously establishes a socket connection by trying each endpoint in a sequ
       typename ``[link boost_asio.reference.Protocol Protocol]``,
       typename ``[link boost_asio.reference.Executor1 Executor]``,
       typename Iterator,
-      typename ``[link boost_asio.reference.IteratorConnectHandler IteratorConnectHandler]``>
+      typename ``[link boost_asio.reference.IteratorConnectHandler IteratorConnectHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_connect.overload2 async_connect]``(
       basic_socket< Protocol, Executor > & s,
       Iterator begin,
-      IteratorConnectHandler && handler,
+      IteratorConnectHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if<!is_endpoint_sequence< Iterator >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_connect.overload2 more...]]``
 
@@ -816,12 +816,12 @@ Asynchronously establishes a socket connection by trying each endpoint in a sequ
       typename ``[link boost_asio.reference.Protocol Protocol]``,
       typename ``[link boost_asio.reference.Executor1 Executor]``,
       typename Iterator,
-      typename ``[link boost_asio.reference.IteratorConnectHandler IteratorConnectHandler]``>
+      typename ``[link boost_asio.reference.IteratorConnectHandler IteratorConnectHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_connect.overload3 async_connect]``(
       basic_socket< Protocol, Executor > & s,
       Iterator begin,
       Iterator end,
-      IteratorConnectHandler && handler);
+      IteratorConnectHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.async_connect.overload3 more...]]``
 
   template<
@@ -829,12 +829,12 @@ Asynchronously establishes a socket connection by trying each endpoint in a sequ
       typename ``[link boost_asio.reference.Executor1 Executor]``,
       typename ``[link boost_asio.reference.EndpointSequence EndpointSequence]``,
       typename ``[link boost_asio.reference.ConnectCondition ConnectCondition]``,
-      typename ``[link boost_asio.reference.RangeConnectHandler RangeConnectHandler]``>
+      typename ``[link boost_asio.reference.RangeConnectHandler RangeConnectHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_connect.overload4 async_connect]``(
       basic_socket< Protocol, Executor > & s,
       const EndpointSequence & endpoints,
       ConnectCondition connect_condition,
-      RangeConnectHandler && handler,
+      RangeConnectHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_endpoint_sequence< EndpointSequence >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_connect.overload4 more...]]``
 
@@ -845,12 +845,12 @@ Asynchronously establishes a socket connection by trying each endpoint in a sequ
       typename ``[link boost_asio.reference.Executor1 Executor]``,
       typename Iterator,
       typename ``[link boost_asio.reference.ConnectCondition ConnectCondition]``,
-      typename ``[link boost_asio.reference.IteratorConnectHandler IteratorConnectHandler]``>
+      typename ``[link boost_asio.reference.IteratorConnectHandler IteratorConnectHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_connect.overload5 async_connect]``(
       basic_socket< Protocol, Executor > & s,
       Iterator begin,
       ConnectCondition connect_condition,
-      IteratorConnectHandler && handler,
+      IteratorConnectHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if<!is_endpoint_sequence< Iterator >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_connect.overload5 more...]]``
 
@@ -861,13 +861,13 @@ Asynchronously establishes a socket connection by trying each endpoint in a sequ
       typename ``[link boost_asio.reference.Executor1 Executor]``,
       typename Iterator,
       typename ``[link boost_asio.reference.ConnectCondition ConnectCondition]``,
-      typename ``[link boost_asio.reference.IteratorConnectHandler IteratorConnectHandler]``>
+      typename ``[link boost_asio.reference.IteratorConnectHandler IteratorConnectHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_connect.overload6 async_connect]``(
       basic_socket< Protocol, Executor > & s,
       Iterator begin,
       Iterator end,
       ConnectCondition connect_condition,
-      IteratorConnectHandler && handler);
+      IteratorConnectHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.async_connect.overload6 more...]]``
 
 [heading Requirements]
@@ -887,11 +887,11 @@ Asynchronously establishes a socket connection by trying each endpoint in a sequ
       typename ``[link boost_asio.reference.Protocol Protocol]``,
       typename ``[link boost_asio.reference.Executor1 Executor]``,
       typename ``[link boost_asio.reference.EndpointSequence EndpointSequence]``,
-      typename ``[link boost_asio.reference.RangeConnectHandler RangeConnectHandler]``>
+      typename ``[link boost_asio.reference.RangeConnectHandler RangeConnectHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
       basic_socket< Protocol, Executor > & s,
       const EndpointSequence & endpoints,
-      RangeConnectHandler && handler,
+      RangeConnectHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_endpoint_sequence< EndpointSequence >::value >::type *  = 0);
 
 
@@ -978,11 +978,11 @@ Regardless of whether the asynchronous operation completes immediately or not, t
       typename ``[link boost_asio.reference.Protocol Protocol]``,
       typename ``[link boost_asio.reference.Executor1 Executor]``,
       typename Iterator,
-      typename ``[link boost_asio.reference.IteratorConnectHandler IteratorConnectHandler]``>
+      typename ``[link boost_asio.reference.IteratorConnectHandler IteratorConnectHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
       basic_socket< Protocol, Executor > & s,
       Iterator begin,
-      IteratorConnectHandler && handler,
+      IteratorConnectHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if<!is_endpoint_sequence< Iterator >::value >::type *  = 0);
 
 
@@ -1037,12 +1037,12 @@ Asynchronously establishes a socket connection by trying each endpoint in a sequ
       typename ``[link boost_asio.reference.Protocol Protocol]``,
       typename ``[link boost_asio.reference.Executor1 Executor]``,
       typename Iterator,
-      typename ``[link boost_asio.reference.IteratorConnectHandler IteratorConnectHandler]``>
+      typename ``[link boost_asio.reference.IteratorConnectHandler IteratorConnectHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
       basic_socket< Protocol, Executor > & s,
       Iterator begin,
       Iterator end,
-      IteratorConnectHandler && handler);
+      IteratorConnectHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 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.
@@ -1117,12 +1117,12 @@ Asynchronously establishes a socket connection by trying each endpoint in a sequ
       typename ``[link boost_asio.reference.Executor1 Executor]``,
       typename ``[link boost_asio.reference.EndpointSequence EndpointSequence]``,
       typename ``[link boost_asio.reference.ConnectCondition ConnectCondition]``,
-      typename ``[link boost_asio.reference.RangeConnectHandler RangeConnectHandler]``>
+      typename ``[link boost_asio.reference.RangeConnectHandler RangeConnectHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
       basic_socket< Protocol, Executor > & s,
       const EndpointSequence & endpoints,
       ConnectCondition connect_condition,
-      RangeConnectHandler && handler,
+      RangeConnectHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_endpoint_sequence< EndpointSequence >::value >::type *  = 0);
 
 
@@ -1242,12 +1242,12 @@ It would be used with the `boost::asio::connect` function as follows:
       typename ``[link boost_asio.reference.Executor1 Executor]``,
       typename Iterator,
       typename ``[link boost_asio.reference.ConnectCondition ConnectCondition]``,
-      typename ``[link boost_asio.reference.IteratorConnectHandler IteratorConnectHandler]``>
+      typename ``[link boost_asio.reference.IteratorConnectHandler IteratorConnectHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
       basic_socket< Protocol, Executor > & s,
       Iterator begin,
       ConnectCondition connect_condition,
-      IteratorConnectHandler && handler,
+      IteratorConnectHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if<!is_endpoint_sequence< Iterator >::value >::type *  = 0);
 
 
@@ -1311,13 +1311,13 @@ Asynchronously establishes a socket connection by trying each endpoint in a sequ
       typename ``[link boost_asio.reference.Executor1 Executor]``,
       typename Iterator,
       typename ``[link boost_asio.reference.ConnectCondition ConnectCondition]``,
-      typename ``[link boost_asio.reference.IteratorConnectHandler IteratorConnectHandler]``>
+      typename ``[link boost_asio.reference.IteratorConnectHandler IteratorConnectHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
       basic_socket< Protocol, Executor > & s,
       Iterator begin,
       Iterator end,
       ConnectCondition connect_condition,
-      IteratorConnectHandler && handler);
+      IteratorConnectHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 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.
@@ -1436,12 +1436,12 @@ It would be used with the `boost::asio::connect` function as follows:
 
   template<
       typename CompletionToken,
-      typename Signature,
+      completion_signature Signature,
       typename Initiation,
       typename... Args>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_initiate(
       Initiation && initiation,
-      BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) ,
+      CompletionToken & ,
       Args &&... args);
 
 
@@ -1466,11 +1466,11 @@ Start an asynchronous operation to read a certain amount of data from a stream.
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read.overload1 async_read]``(
       AsyncReadStream & s,
       const MutableBufferSequence & buffers,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_mutable_buffer_sequence< MutableBufferSequence >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read.overload1 more...]]``
 
@@ -1478,23 +1478,23 @@ Start an asynchronous operation to read a certain amount of data from a stream.
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
       typename ``[link boost_asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read.overload2 async_read]``(
       AsyncReadStream & s,
       const MutableBufferSequence & buffers,
       CompletionCondition completion_condition,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_mutable_buffer_sequence< MutableBufferSequence >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read.overload2 more...]]``
 
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read.overload3 async_read]``(
       AsyncReadStream & s,
       DynamicBuffer_v1 && buffers,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v1< typename decay< DynamicBuffer_v1 >::type >::value &&!is_dynamic_buffer_v2< typename decay< DynamicBuffer_v1 >::type >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read.overload3 more...]]``
 
@@ -1502,45 +1502,45 @@ Start an asynchronous operation to read a certain amount of data from a stream.
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
       typename ``[link boost_asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read.overload4 async_read]``(
       AsyncReadStream & s,
       DynamicBuffer_v1 && buffers,
       CompletionCondition completion_condition,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v1< typename decay< DynamicBuffer_v1 >::type >::value &&!is_dynamic_buffer_v2< typename decay< DynamicBuffer_v1 >::type >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read.overload4 more...]]``
 
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename Allocator,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read.overload5 async_read]``(
       AsyncReadStream & s,
       basic_streambuf< Allocator > & b,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read.overload5 more...]]``
 
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename Allocator,
       typename ``[link boost_asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read.overload6 async_read]``(
       AsyncReadStream & s,
       basic_streambuf< Allocator > & b,
       CompletionCondition completion_condition,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read.overload6 more...]]``
 
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read.overload7 async_read]``(
       AsyncReadStream & s,
       DynamicBuffer_v2 buffers,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read.overload7 more...]]``
 
@@ -1548,12 +1548,12 @@ Start an asynchronous operation to read a certain amount of data from a stream.
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
       typename ``[link boost_asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read.overload8 async_read]``(
       AsyncReadStream & s,
       DynamicBuffer_v2 buffers,
       CompletionCondition completion_condition,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read.overload8 more...]]``
 
@@ -1573,11 +1573,11 @@ Start an asynchronous operation to read a certain amount of data from a stream.
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read(
       AsyncReadStream & s,
       const MutableBufferSequence & buffers,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_mutable_buffer_sequence< MutableBufferSequence >::value >::type *  = 0);
 
 
@@ -1657,12 +1657,12 @@ Start an asynchronous operation to read a certain amount of data from a stream.
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
       typename ``[link boost_asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read(
       AsyncReadStream & s,
       const MutableBufferSequence & buffers,
       CompletionCondition completion_condition,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_mutable_buffer_sequence< MutableBufferSequence >::value >::type *  = 0);
 
 
@@ -1741,11 +1741,11 @@ Start an asynchronous operation to read a certain amount of data from a stream.
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read(
       AsyncReadStream & s,
       DynamicBuffer_v1 && buffers,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v1< typename decay< DynamicBuffer_v1 >::type >::value &&!is_dynamic_buffer_v2< typename decay< DynamicBuffer_v1 >::type >::value >::type *  = 0);
 
 
@@ -1815,12 +1815,12 @@ Start an asynchronous operation to read a certain amount of data from a stream.
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
       typename ``[link boost_asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read(
       AsyncReadStream & s,
       DynamicBuffer_v1 && buffers,
       CompletionCondition completion_condition,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v1< typename decay< DynamicBuffer_v1 >::type >::value &&!is_dynamic_buffer_v2< typename decay< DynamicBuffer_v1 >::type >::value >::type *  = 0);
 
 
@@ -1888,11 +1888,11 @@ Start an asynchronous operation to read a certain amount of data from a stream.
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename Allocator,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read(
       AsyncReadStream & s,
       basic_streambuf< Allocator > & b,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 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:
@@ -1961,12 +1961,12 @@ Start an asynchronous operation to read a certain amount of data from a stream.
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename Allocator,
       typename ``[link boost_asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read(
       AsyncReadStream & s,
       basic_streambuf< Allocator > & b,
       CompletionCondition completion_condition,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 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:
@@ -2033,11 +2033,11 @@ Start an asynchronous operation to read a certain amount of data from a stream.
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read(
       AsyncReadStream & s,
       DynamicBuffer_v2 buffers,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >::type *  = 0);
 
 
@@ -2107,12 +2107,12 @@ Start an asynchronous operation to read a certain amount of data from a stream.
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
       typename ``[link boost_asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read(
       AsyncReadStream & s,
       DynamicBuffer_v2 buffers,
       CompletionCondition completion_condition,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >::type *  = 0);
 
 
@@ -2183,49 +2183,49 @@ Start an asynchronous operation to read a certain amount of data at the specifie
   template<
       typename ``[link boost_asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read_at.overload1 async_read_at]``(
       AsyncRandomAccessReadDevice & d,
       uint64_t offset,
       const MutableBufferSequence & buffers,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read_at.overload1 more...]]``
 
   template<
       typename ``[link boost_asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
       typename ``[link boost_asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read_at.overload2 async_read_at]``(
       AsyncRandomAccessReadDevice & d,
       uint64_t offset,
       const MutableBufferSequence & buffers,
       CompletionCondition completion_condition,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read_at.overload2 more...]]``
 
   template<
       typename ``[link boost_asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
       typename Allocator,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read_at.overload3 async_read_at]``(
       AsyncRandomAccessReadDevice & d,
       uint64_t offset,
       basic_streambuf< Allocator > & b,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read_at.overload3 more...]]``
 
   template<
       typename ``[link boost_asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
       typename Allocator,
       typename ``[link boost_asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read_at.overload4 async_read_at]``(
       AsyncRandomAccessReadDevice & d,
       uint64_t offset,
       basic_streambuf< Allocator > & b,
       CompletionCondition completion_condition,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read_at.overload4 more...]]``
 
 [heading Requirements]
@@ -2244,12 +2244,12 @@ Start an asynchronous operation to read a certain amount of data at the specifie
   template<
       typename ``[link boost_asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_at(
       AsyncRandomAccessReadDevice & d,
       uint64_t offset,
       const MutableBufferSequence & buffers,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 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:
@@ -2330,13 +2330,13 @@ Start an asynchronous operation to read a certain amount of data at the specifie
       typename ``[link boost_asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
       typename ``[link boost_asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_at(
       AsyncRandomAccessReadDevice & d,
       uint64_t offset,
       const MutableBufferSequence & buffers,
       CompletionCondition completion_condition,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 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:
@@ -2416,12 +2416,12 @@ Start an asynchronous operation to read a certain amount of data at the specifie
   template<
       typename ``[link boost_asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
       typename Allocator,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_at(
       AsyncRandomAccessReadDevice & d,
       uint64_t offset,
       basic_streambuf< Allocator > & b,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 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:
@@ -2489,13 +2489,13 @@ Start an asynchronous operation to read a certain amount of data at the specifie
       typename ``[link boost_asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
       typename Allocator,
       typename ``[link boost_asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_at(
       AsyncRandomAccessReadDevice & d,
       uint64_t offset,
       basic_streambuf< Allocator > & b,
       CompletionCondition completion_condition,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 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:
@@ -2564,24 +2564,24 @@ Start an asynchronous operation to read data into a dynamic buffer sequence unti
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read_until.overload1 async_read_until]``(
       AsyncReadStream & s,
       DynamicBuffer_v1 && buffers,
       char delim,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v1< typename decay< DynamicBuffer_v1 >::type >::value &&!is_dynamic_buffer_v2< typename decay< DynamicBuffer_v1 >::type >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read_until.overload1 more...]]``
 
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read_until.overload2 async_read_until]``(
       AsyncReadStream & s,
       DynamicBuffer_v1 && buffers,
       string_view delim,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v1< typename decay< DynamicBuffer_v1 >::type >::value &&!is_dynamic_buffer_v2< typename decay< DynamicBuffer_v1 >::type >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read_until.overload2 more...]]``
 
@@ -2590,12 +2590,12 @@ Start an asynchronous operation to read data into a dynamic buffer sequence unti
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read_until.overload3 async_read_until]``(
       AsyncReadStream & s,
       DynamicBuffer_v1 && buffers,
       const boost::regex & expr,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v1< typename decay< DynamicBuffer_v1 >::type >::value &&!is_dynamic_buffer_v2< typename decay< DynamicBuffer_v1 >::type >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read_until.overload3 more...]]``
 
@@ -2605,12 +2605,12 @@ Start an asynchronous operation to read data into a dynamic buffer sequence unti
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
       typename MatchCondition,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read_until.overload4 async_read_until]``(
       AsyncReadStream & s,
       DynamicBuffer_v1 && buffers,
       MatchCondition match_condition,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_match_condition< MatchCondition >::value &&is_dynamic_buffer_v1< typename decay< DynamicBuffer_v1 >::type >::value &&!is_dynamic_buffer_v2< typename decay< DynamicBuffer_v1 >::type >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read_until.overload4 more...]]``
 
@@ -2619,23 +2619,23 @@ Start an asynchronous operation to read data into a streambuf until it contains
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename Allocator,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read_until.overload5 async_read_until]``(
       AsyncReadStream & s,
       boost::asio::basic_streambuf< Allocator > & b,
       char delim,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read_until.overload5 more...]]``
 
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename Allocator,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read_until.overload6 async_read_until]``(
       AsyncReadStream & s,
       boost::asio::basic_streambuf< Allocator > & b,
       string_view delim,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read_until.overload6 more...]]``
 
 Start an asynchronous operation to read data into a streambuf until some part of its data matches a regular expression. 
@@ -2643,12 +2643,12 @@ Start an asynchronous operation to read data into a streambuf until some part of
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename Allocator,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read_until.overload7 async_read_until]``(
       AsyncReadStream & s,
       boost::asio::basic_streambuf< Allocator > & b,
       const boost::regex & expr,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read_until.overload7 more...]]``
 
 Start an asynchronous operation to read data into a streambuf until a function object indicates a match. 
@@ -2657,12 +2657,12 @@ Start an asynchronous operation to read data into a streambuf until a function o
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename Allocator,
       typename MatchCondition,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read_until.overload8 async_read_until]``(
       AsyncReadStream & s,
       boost::asio::basic_streambuf< Allocator > & b,
       MatchCondition match_condition,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_match_condition< MatchCondition >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read_until.overload8 more...]]``
 
@@ -2671,24 +2671,24 @@ Start an asynchronous operation to read data into a dynamic buffer sequence unti
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read_until.overload9 async_read_until]``(
       AsyncReadStream & s,
       DynamicBuffer_v2 buffers,
       char delim,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read_until.overload9 more...]]``
 
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read_until.overload10 async_read_until]``(
       AsyncReadStream & s,
       DynamicBuffer_v2 buffers,
       string_view delim,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read_until.overload10 more...]]``
 
@@ -2697,12 +2697,12 @@ Start an asynchronous operation to read data into a dynamic buffer sequence unti
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read_until.overload11 async_read_until]``(
       AsyncReadStream & s,
       DynamicBuffer_v2 buffers,
       const boost::regex & expr,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read_until.overload11 more...]]``
 
@@ -2712,12 +2712,12 @@ Start an asynchronous operation to read data into a dynamic buffer sequence unti
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
       typename MatchCondition,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_read_until.overload12 async_read_until]``(
       AsyncReadStream & s,
       DynamicBuffer_v2 buffers,
       MatchCondition match_condition,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_match_condition< MatchCondition >::value &&is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_read_until.overload12 more...]]``
 
@@ -2737,12 +2737,12 @@ Start an asynchronous operation to read data into a dynamic buffer sequence unti
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
       AsyncReadStream & s,
       DynamicBuffer_v1 && buffers,
       char delim,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v1< typename decay< DynamicBuffer_v1 >::type >::value &&!is_dynamic_buffer_v2< typename decay< DynamicBuffer_v1 >::type >::value >::type *  = 0);
 
 
@@ -2842,12 +2842,12 @@ Start an asynchronous operation to read data into a dynamic buffer sequence unti
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
       AsyncReadStream & s,
       DynamicBuffer_v1 && buffers,
       string_view delim,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v1< typename decay< DynamicBuffer_v1 >::type >::value &&!is_dynamic_buffer_v2< typename decay< DynamicBuffer_v1 >::type >::value >::type *  = 0);
 
 
@@ -2947,12 +2947,12 @@ Start an asynchronous operation to read data into a dynamic buffer sequence unti
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
       AsyncReadStream & s,
       DynamicBuffer_v1 && buffers,
       const boost::regex & expr,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v1< typename decay< DynamicBuffer_v1 >::type >::value &&!is_dynamic_buffer_v2< typename decay< DynamicBuffer_v1 >::type >::value >::type *  = 0);
 
 
@@ -3055,12 +3055,12 @@ Start an asynchronous operation to read data into a dynamic buffer sequence unti
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
       typename MatchCondition,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
       AsyncReadStream & s,
       DynamicBuffer_v1 && buffers,
       MatchCondition match_condition,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_match_condition< MatchCondition >::value &&is_dynamic_buffer_v1< typename decay< DynamicBuffer_v1 >::type >::value &&!is_dynamic_buffer_v2< typename decay< DynamicBuffer_v1 >::type >::value >::type *  = 0);
 
 
@@ -3192,12 +3192,12 @@ Start an asynchronous operation to read data into a streambuf until it contains
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename Allocator,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
       AsyncReadStream & s,
       boost::asio::basic_streambuf< Allocator > & b,
       char delim,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 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:
@@ -3297,12 +3297,12 @@ Start an asynchronous operation to read data into a streambuf until it contains
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename Allocator,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
       AsyncReadStream & s,
       boost::asio::basic_streambuf< Allocator > & b,
       string_view delim,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 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:
@@ -3402,12 +3402,12 @@ Start an asynchronous operation to read data into a streambuf until some part of
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename Allocator,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
       AsyncReadStream & s,
       boost::asio::basic_streambuf< Allocator > & b,
       const boost::regex & expr,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 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:
@@ -3509,12 +3509,12 @@ Start an asynchronous operation to read data into a streambuf until a function o
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename Allocator,
       typename MatchCondition,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
       AsyncReadStream & s,
       boost::asio::basic_streambuf< Allocator > & b,
       MatchCondition match_condition,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_match_condition< MatchCondition >::value >::type *  = 0);
 
 
@@ -3646,12 +3646,12 @@ Start an asynchronous operation to read data into a dynamic buffer sequence unti
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
       AsyncReadStream & s,
       DynamicBuffer_v2 buffers,
       char delim,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >::type *  = 0);
 
 
@@ -3751,12 +3751,12 @@ Start an asynchronous operation to read data into a dynamic buffer sequence unti
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
       AsyncReadStream & s,
       DynamicBuffer_v2 buffers,
       string_view delim,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >::type *  = 0);
 
 
@@ -3856,12 +3856,12 @@ Start an asynchronous operation to read data into a dynamic buffer sequence unti
   template<
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
       AsyncReadStream & s,
       DynamicBuffer_v2 buffers,
       const boost::regex & expr,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >::type *  = 0);
 
 
@@ -3964,12 +3964,12 @@ Start an asynchronous operation to read data into a dynamic buffer sequence unti
       typename ``[link boost_asio.reference.AsyncReadStream AsyncReadStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
       typename MatchCondition,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
       AsyncReadStream & s,
       DynamicBuffer_v2 buffers,
       MatchCondition match_condition,
-      ReadHandler && handler,
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_match_condition< MatchCondition >::value &&is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >::type *  = 0);
 
 
@@ -4404,11 +4404,11 @@ Start an asynchronous operation to write all of the supplied data to a stream.
   template<
       typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_write.overload1 async_write]``(
       AsyncWriteStream & s,
       const ConstBufferSequence & buffers,
-      WriteHandler && handler,
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_const_buffer_sequence< ConstBufferSequence >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_write.overload1 more...]]``
 
@@ -4432,11 +4432,11 @@ Start an asynchronous operation to write all of the supplied data to a stream.
   template<
       typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_write.overload3 async_write]``(
       AsyncWriteStream & s,
       DynamicBuffer_v1 && buffers,
-      WriteHandler && handler,
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v1< typename decay< DynamicBuffer_v1 >::type >::value &&!is_dynamic_buffer_v2< typename decay< DynamicBuffer_v1 >::type >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_write.overload3 more...]]``
 
@@ -4460,11 +4460,11 @@ Start an asynchronous operation to write all of the supplied data to a stream.
   template<
       typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
       typename Allocator,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_write.overload5 async_write]``(
       AsyncWriteStream & s,
       basic_streambuf< Allocator > & b,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.async_write.overload5 more...]]``
 
 Start an asynchronous operation to write a certain amount of data to a stream. 
@@ -4486,11 +4486,11 @@ Start an asynchronous operation to write all of the supplied data to a stream.
   template<
       typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_write.overload7 async_write]``(
       AsyncWriteStream & s,
       DynamicBuffer_v2 buffers,
-      WriteHandler && handler,
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.async_write.overload7 more...]]``
 
@@ -4525,11 +4525,11 @@ Start an asynchronous operation to write all of the supplied data to a stream.
   template<
       typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write(
       AsyncWriteStream & s,
       const ConstBufferSequence & buffers,
-      WriteHandler && handler,
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_const_buffer_sequence< ConstBufferSequence >::value >::type *  = 0);
 
 
@@ -4680,274 +4680,274 @@ Start an asynchronous operation to write all of the supplied data to a stream.
   template<
       typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
       typename ``[link boost_asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
+  ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write(
+      AsyncWriteStream & s,
+      DynamicBuffer_v1 && buffers,
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
+      typename enable_if< is_dynamic_buffer_v1< typename decay< DynamicBuffer_v1 >::type >::value &&!is_dynamic_buffer_v2< typename decay< DynamicBuffer_v1 >::type >::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 boost::system::error_code& error, // Result of operation.
+
+     std::size_t bytes_transferred           // Number of bytes written from the
+                                             // buffers. If an error occurred,
+                                             // this will be less than the sum
+                                             // of the buffer sizes.
+   ); 
+``
+Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link boost_asio.reference.post `post`]. ]]
+
+]
+
+
+
+
+[endsect]
+
+
+
+[section:overload4 async_write (4 of 8 overloads)]
+
+
+Start an asynchronous operation to write a certain amount of data to a stream. 
+
+
+  template<
+      typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
+      typename ``[link boost_asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
+      typename ``[link boost_asio.reference.CompletionCondition CompletionCondition]``,
       typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write(
       AsyncWriteStream & s,
       DynamicBuffer_v1 && buffers,
+      CompletionCondition completion_condition,
       WriteHandler && handler,
       typename enable_if< is_dynamic_buffer_v1< typename decay< DynamicBuffer_v1 >::type >::value &&!is_dynamic_buffer_v2< typename decay< DynamicBuffer_v1 >::type >::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 boost::system::error_code& error, // Result of operation.
-
-     std::size_t bytes_transferred           // Number of bytes written from the
-                                             // buffers. If an error occurred,
-                                             // this will be less than the sum
-                                             // of the buffer sizes.
-   ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link boost_asio.reference.post `post`]. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 async_write (4 of 8 overloads)]
-
-
-Start an asynchronous operation to write a certain amount of data to a stream. 
-
-
-  template<
-      typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
-      typename ``[link boost_asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link boost_asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
-  ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write(
-      AsyncWriteStream & s,
-      DynamicBuffer_v1 && buffers,
-      CompletionCondition completion_condition,
-      WriteHandler && handler,
-      typename enable_if< is_dynamic_buffer_v1< typename decay< DynamicBuffer_v1 >::type >::value &&!is_dynamic_buffer_v2< typename decay< DynamicBuffer_v1 >::type >::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 boost::system::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 boost::system::error_code& error, // Result of operation.
-
-     std::size_t bytes_transferred           // Number of bytes written from the
-                                             // buffers. If an error occurred,
-                                             // this will be less than the sum
-                                             // of the buffer sizes.
-   ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link boost_asio.reference.post `post`]. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 async_write (5 of 8 overloads)]
-
-
-Start an asynchronous operation to write all of the supplied data to a stream. 
-
-
-  template<
-      typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
-      typename Allocator,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
-  ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write(
-      AsyncWriteStream & s,
-      basic_streambuf< Allocator > & b,
-      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:
-
-
-* All of the data in the supplied [link boost_asio.reference.basic_streambuf `basic_streambuf`] 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.]]
-
-[[b][A [link boost_asio.reference.basic_streambuf `basic_streambuf`] object from which data will be written. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the handler is called.]]
-
-[[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 boost::system::error_code& error, // Result of operation.
-
-     std::size_t bytes_transferred           // Number of bytes written from the
-                                             // buffers. If an error occurred,
-                                             // this will be less than the sum
-                                             // of the buffer sizes.
-   ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link boost_asio.reference.post `post`]. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 async_write (6 of 8 overloads)]
-
-
-Start an asynchronous operation to write a certain amount of data to a stream. 
-
-
-  template<
-      typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
-      typename Allocator,
-      typename ``[link boost_asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
-  ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write(
-      AsyncWriteStream & s,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      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:
-
-
-* All of the data in the supplied [link boost_asio.reference.basic_streambuf `basic_streambuf`] 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.]]
-
-[[b][A [link boost_asio.reference.basic_streambuf `basic_streambuf`] object from which data will be written. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the handler is called.]]
-
-[[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 boost::system::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 boost::system::error_code& error, // Result of operation.
-
-     std::size_t bytes_transferred           // Number of bytes written from the
-                                             // buffers. If an error occurred,
-                                             // this will be less than the sum
-                                             // of the buffer sizes.
-   ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link boost_asio.reference.post `post`]. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 async_write (7 of 8 overloads)]
-
-
-Start an asynchronous operation to write all of the supplied data to a stream. 
-
-
-  template<
-      typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
-      typename ``[link boost_asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
-  ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write(
-      AsyncWriteStream & s,
-      DynamicBuffer_v2 buffers,
-      WriteHandler && handler,
-      typename enable_if< is_dynamic_buffer_v2< DynamicBuffer_v2 >::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 boost::system::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 boost::system::error_code& error, // Result of operation.
+
+     std::size_t bytes_transferred           // Number of bytes written from the
+                                             // buffers. If an error occurred,
+                                             // this will be less than the sum
+                                             // of the buffer sizes.
+   ); 
+``
+Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link boost_asio.reference.post `post`]. ]]
+
+]
+
+
+
+
+[endsect]
+
+
+
+[section:overload5 async_write (5 of 8 overloads)]
+
+
+Start an asynchronous operation to write all of the supplied data to a stream. 
+
+
+  template<
+      typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
+      typename Allocator,
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
+  ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write(
+      AsyncWriteStream & s,
+      basic_streambuf< Allocator > & b,
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
+
+
+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 [link boost_asio.reference.basic_streambuf `basic_streambuf`] 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.]]
+
+[[b][A [link boost_asio.reference.basic_streambuf `basic_streambuf`] object from which data will be written. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the handler is called.]]
+
+[[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 boost::system::error_code& error, // Result of operation.
+
+     std::size_t bytes_transferred           // Number of bytes written from the
+                                             // buffers. If an error occurred,
+                                             // this will be less than the sum
+                                             // of the buffer sizes.
+   ); 
+``
+Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link boost_asio.reference.post `post`]. ]]
+
+]
+
+
+
+
+[endsect]
+
+
+
+[section:overload6 async_write (6 of 8 overloads)]
+
+
+Start an asynchronous operation to write a certain amount of data to a stream. 
+
+
+  template<
+      typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
+      typename Allocator,
+      typename ``[link boost_asio.reference.CompletionCondition CompletionCondition]``,
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+  ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write(
+      AsyncWriteStream & s,
+      basic_streambuf< Allocator > & b,
+      CompletionCondition completion_condition,
+      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:
+
+
+* All of the data in the supplied [link boost_asio.reference.basic_streambuf `basic_streambuf`] 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.]]
+
+[[b][A [link boost_asio.reference.basic_streambuf `basic_streambuf`] object from which data will be written. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the handler is called.]]
+
+[[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 boost::system::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 boost::system::error_code& error, // Result of operation.
+
+     std::size_t bytes_transferred           // Number of bytes written from the
+                                             // buffers. If an error occurred,
+                                             // this will be less than the sum
+                                             // of the buffer sizes.
+   ); 
+``
+Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link boost_asio.reference.post `post`]. ]]
+
+]
+
+
+
+
+[endsect]
+
+
+
+[section:overload7 async_write (7 of 8 overloads)]
+
+
+Start an asynchronous operation to write all of the supplied data to a stream. 
+
+
+  template<
+      typename ``[link boost_asio.reference.AsyncWriteStream AsyncWriteStream]``,
+      typename ``[link boost_asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
+  ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write(
+      AsyncWriteStream & s,
+      DynamicBuffer_v2 buffers,
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
+      typename enable_if< is_dynamic_buffer_v2< DynamicBuffer_v2 >::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:
@@ -5077,12 +5077,12 @@ Start an asynchronous operation to write all of the supplied data at the specifi
   template<
       typename ``[link boost_asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_write_at.overload1 async_write_at]``(
       AsyncRandomAccessWriteDevice & d,
       uint64_t offset,
       const ConstBufferSequence & buffers,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.async_write_at.overload1 more...]]``
 
 Start an asynchronous operation to write a certain amount of data at the specified offset. 
@@ -5091,13 +5091,13 @@ Start an asynchronous operation to write a certain amount of data at the specifi
       typename ``[link boost_asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
       typename ``[link boost_asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_write_at.overload2 async_write_at]``(
       AsyncRandomAccessWriteDevice & d,
       uint64_t offset,
       const ConstBufferSequence & buffers,
       CompletionCondition completion_condition,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.async_write_at.overload2 more...]]``
 
 Start an asynchronous operation to write all of the supplied data at the specified offset. 
@@ -5105,12 +5105,12 @@ Start an asynchronous operation to write all of the supplied data at the specifi
   template<
       typename ``[link boost_asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
       typename Allocator,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_write_at.overload3 async_write_at]``(
       AsyncRandomAccessWriteDevice & d,
       uint64_t offset,
       basic_streambuf< Allocator > & b,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.async_write_at.overload3 more...]]``
 
 Start an asynchronous operation to write a certain amount of data at the specified offset. 
@@ -5119,13 +5119,13 @@ Start an asynchronous operation to write a certain amount of data at the specifi
       typename ``[link boost_asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
       typename Allocator,
       typename ``[link boost_asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.async_write_at.overload4 async_write_at]``(
       AsyncRandomAccessWriteDevice & d,
       uint64_t offset,
       basic_streambuf< Allocator > & b,
       CompletionCondition completion_condition,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.async_write_at.overload4 more...]]``
 
 [heading Requirements]
@@ -5144,12 +5144,12 @@ Start an asynchronous operation to write all of the supplied data at the specifi
   template<
       typename ``[link boost_asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_at(
       AsyncRandomAccessWriteDevice & d,
       uint64_t offset,
       const ConstBufferSequence & buffers,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 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:
@@ -5216,13 +5216,13 @@ Start an asynchronous operation to write a certain amount of data at the specifi
       typename ``[link boost_asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
       typename ``[link boost_asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_at(
       AsyncRandomAccessWriteDevice & d,
       uint64_t offset,
       const ConstBufferSequence & buffers,
       CompletionCondition completion_condition,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 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:
@@ -5303,12 +5303,12 @@ Start an asynchronous operation to write all of the supplied data at the specifi
   template<
       typename ``[link boost_asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
       typename Allocator,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_at(
       AsyncRandomAccessWriteDevice & d,
       uint64_t offset,
       basic_streambuf< Allocator > & b,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 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:
@@ -5365,13 +5365,13 @@ Start an asynchronous operation to write a certain amount of data at the specifi
       typename ``[link boost_asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
       typename Allocator,
       typename ``[link boost_asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_at(
       AsyncRandomAccessWriteDevice & d,
       uint64_t offset,
       basic_streambuf< Allocator > & b,
       CompletionCondition completion_condition,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 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:
@@ -6181,10 +6181,10 @@ Start an asynchronous connect.
 
 
   template<
-      typename ``[link boost_asio.reference.ConnectHandler ConnectHandler]``>
+      typename ``[link boost_asio.reference.ConnectHandler ConnectHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
       const endpoint_type & peer_endpoint,
-      ConnectHandler && handler);
+      ConnectHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously connect a socket to the specified remote endpoint. The function call always returns immediately.
@@ -6246,19 +6246,19 @@ Start an asynchronous receive on a connected socket.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_datagram_socket.async_receive.overload1 async_receive]``(
       const MutableBufferSequence & buffers,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_datagram_socket.async_receive.overload1 more...]]``
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_datagram_socket.async_receive.overload2 async_receive]``(
       const MutableBufferSequence & buffers,
       socket_base::message_flags flags,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_datagram_socket.async_receive.overload2 more...]]``
 
 
@@ -6270,10 +6270,10 @@ Start an asynchronous receive on a connected socket.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive(
       const MutableBufferSequence & buffers,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously receive data from the datagram socket. The function call always returns immediately.
@@ -6327,11 +6327,11 @@ Start an asynchronous receive on a connected socket.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive(
       const MutableBufferSequence & buffers,
       socket_base::message_flags flags,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously receive data from the datagram socket. The function call always returns immediately.
@@ -6378,21 +6378,21 @@ Start an asynchronous receive.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_datagram_socket.async_receive_from.overload1 async_receive_from]``(
       const MutableBufferSequence & buffers,
       endpoint_type & sender_endpoint,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_datagram_socket.async_receive_from.overload1 more...]]``
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_datagram_socket.async_receive_from.overload2 async_receive_from]``(
       const MutableBufferSequence & buffers,
       endpoint_type & sender_endpoint,
       socket_base::message_flags flags,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_datagram_socket.async_receive_from.overload2 more...]]``
 
 
@@ -6404,11 +6404,11 @@ Start an asynchronous receive.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive_from(
       const MutableBufferSequence & buffers,
       endpoint_type & sender_endpoint,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously receive a datagram. The function call always returns immediately.
@@ -6460,12 +6460,12 @@ Start an asynchronous receive.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive_from(
       const MutableBufferSequence & buffers,
       endpoint_type & sender_endpoint,
       socket_base::message_flags flags,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously receive a datagram. The function call always returns immediately.
@@ -6509,19 +6509,19 @@ Start an asynchronous send on a connected socket.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_datagram_socket.async_send.overload1 async_send]``(
       const ConstBufferSequence & buffers,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_datagram_socket.async_send.overload1 more...]]``
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_datagram_socket.async_send.overload2 async_send]``(
       const ConstBufferSequence & buffers,
       socket_base::message_flags flags,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_datagram_socket.async_send.overload2 more...]]``
 
 
@@ -6533,10 +6533,10 @@ Start an asynchronous send on a connected socket.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send(
       const ConstBufferSequence & buffers,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously send data on the datagram socket. The function call always returns immediately.
@@ -6590,11 +6590,11 @@ Start an asynchronous send on a connected socket.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send(
       const ConstBufferSequence & buffers,
       socket_base::message_flags flags,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously send data on the datagram socket. The function call always returns immediately.
@@ -6641,21 +6641,21 @@ Start an asynchronous send.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_datagram_socket.async_send_to.overload1 async_send_to]``(
       const ConstBufferSequence & buffers,
       const endpoint_type & destination,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_datagram_socket.async_send_to.overload1 more...]]``
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_datagram_socket.async_send_to.overload2 async_send_to]``(
       const ConstBufferSequence & buffers,
       const endpoint_type & destination,
       socket_base::message_flags flags,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_datagram_socket.async_send_to.overload2 more...]]``
 
 
@@ -6667,11 +6667,11 @@ Start an asynchronous send.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send_to(
       const ConstBufferSequence & buffers,
       const endpoint_type & destination,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously send a datagram to the specified remote endpoint. The function call always returns immediately.
@@ -6725,12 +6725,12 @@ Start an asynchronous send.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send_to(
       const ConstBufferSequence & buffers,
       const endpoint_type & destination,
       socket_base::message_flags flags,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously send a datagram to the specified remote endpoint. The function call always returns immediately.
@@ -6777,10 +6777,10 @@ Asynchronously wait for the socket to become ready to read, ready to write, or t
 
 
   template<
-      typename ``[link boost_asio.reference.WaitHandler WaitHandler]``>
+      typename ``[link boost_asio.reference.WaitHandler WaitHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
       wait_type w,
-      WaitHandler && handler);
+      WaitHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to perform an asynchronous wait for a socket to enter a ready to read, write or error condition state.
@@ -12441,6 +12441,13 @@ Provides waitable timer functionality.
 
   [
 
+    [[link boost_asio.reference.basic_deadline_timer__rebind_executor [*rebind_executor]]]
+    [Rebinds the timer type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.basic_deadline_timer.duration_type [*duration_type]]]
     [The duration type. ]
   
@@ -12643,9 +12650,9 @@ Start an asynchronous wait on the timer.
 
 
   template<
-      typename ``[link boost_asio.reference.WaitHandler WaitHandler]``>
+      typename ``[link boost_asio.reference.WaitHandler WaitHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
-      WaitHandler && handler);
+      WaitHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function may be used to initiate an asynchronous wait against the timer. It always returns immediately.
@@ -13695,6 +13702,261 @@ This function destroys the timer, cancelling any outstanding asynchronous wait o
 
 [endsect]
 
+[section:basic_deadline_timer__rebind_executor basic_deadline_timer::rebind_executor]
+
+
+Rebinds the timer type to another executor. 
+
+
+  template<
+      typename ``[link boost_asio.reference.Executor1 Executor1]``>
+  struct rebind_executor
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.basic_deadline_timer__rebind_executor.other [*other]]]
+    [The timer type when rebound to the specified executor. ]
+  
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^boost/asio/basic_deadline_timer.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[section:other basic_deadline_timer::rebind_executor::other]
+
+[indexterm2 boost_asio.indexterm.basic_deadline_timer__rebind_executor.other..other..basic_deadline_timer::rebind_executor] 
+The timer type when rebound to the specified executor. 
+
+
+  typedef basic_deadline_timer< Time, TimeTraits, Executor1 > other;
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.basic_deadline_timer__rebind_executor [*rebind_executor]]]
+    [Rebinds the timer type to another executor. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_deadline_timer.duration_type [*duration_type]]]
+    [The duration type. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_deadline_timer.executor_type [*executor_type]]]
+    [The type of the executor associated with the object. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_deadline_timer.time_type [*time_type]]]
+    [The time type. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_deadline_timer.traits_type [*traits_type]]]
+    [The time traits type. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.basic_deadline_timer.async_wait [*async_wait]]]
+    [Start an asynchronous wait on the timer. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_deadline_timer.basic_deadline_timer [*basic_deadline_timer]]]
+    [Constructor. 
+     [hr]
+     Constructor to set a particular expiry time as an absolute time. 
+     [hr]
+     Constructor to set a particular expiry time relative to now. 
+     [hr]
+     Move-construct a basic_deadline_timer from another. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_deadline_timer.cancel [*cancel]]]
+    [Cancel any asynchronous operations that are waiting on the timer. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_deadline_timer.cancel_one [*cancel_one]]]
+    [Cancels one asynchronous operation that is waiting on the timer. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_deadline_timer.expires_at [*expires_at]]]
+    [Get the timer's expiry time as an absolute time. 
+     [hr]
+     Set the timer's expiry time as an absolute time. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_deadline_timer.expires_from_now [*expires_from_now]]]
+    [Get the timer's expiry time relative to now. 
+     [hr]
+     Set the timer's expiry time relative to now. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_deadline_timer.get_executor [*get_executor]]]
+    [Get the executor associated with the object. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_deadline_timer.operator_eq_ [*operator=]]]
+    [Move-assign a basic_deadline_timer from another. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_deadline_timer.wait [*wait]]]
+    [Perform a blocking wait on the timer. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_deadline_timer._basic_deadline_timer [*~basic_deadline_timer]]]
+    [Destroys the timer. ]
+  ]
+  
+]
+
+The [link boost_asio.reference.basic_deadline_timer `basic_deadline_timer`] class template provides the ability to perform a blocking or asynchronous wait for a timer to expire.
+
+A deadline timer is always in one of two states: "expired" or "not expired". If the `wait()` or `async_wait()` function is called on an expired timer, the wait operation will complete immediately.
+
+Most applications will use the [link boost_asio.reference.deadline_timer `deadline_timer`] typedef.
+
+
+[heading Thread Safety]
+  
+['Distinct] ['objects:] Safe.
+
+['Shared] ['objects:] Unsafe.
+
+
+[heading Examples]
+  
+Performing a blocking wait: 
+
+   // Construct a timer without setting an expiry time.
+   boost::asio::deadline_timer timer(my_context);
+
+   // Set an expiry time relative to now.
+   timer.expires_from_now(boost::posix_time::seconds(5));
+
+   // Wait for the timer to expire.
+   timer.wait();
+
+
+
+
+
+Performing an asynchronous wait: 
+
+   void handler(const boost::system::error_code& error)
+   {
+     if (!error)
+     {
+       // Timer expired.
+     }
+   }
+
+   ...
+
+   // Construct a timer with an absolute expiry time.
+   boost::asio::deadline_timer timer(my_context,
+       boost::posix_time::time_from_string("2005-12-07 23:59:59.000"));
+
+   // Start an asynchronous wait.
+   timer.async_wait(handler);
+
+
+
+
+
+[heading Changing an active deadline_timer's expiry time]
+  
+
+
+Changing the expiry time of a timer while there are pending asynchronous waits causes those wait operations to be cancelled. To ensure that the action associated with the timer is performed only once, use something like this: used:
+
+
+
+   void on_some_event()
+   {
+     if (my_timer.expires_from_now(seconds(5)) > 0)
+     {
+       // We managed to cancel the timer. Start new asynchronous wait.
+       my_timer.async_wait(on_timeout);
+     }
+     else
+     {
+       // Too late, timer has already expired!
+     }
+   }
+
+   void on_timeout(const boost::system::error_code& e)
+   {
+     if (e != boost::asio::error::operation_aborted)
+     {
+       // Timer was not cancelled, take necessary action.
+     }
+   }
+
+
+
+
+
+* The `boost::asio::basic_deadline_timer::expires_from_now()` function cancels any pending asynchronous waits, and returns the number of asynchronous waits that were cancelled. If it returns 0 then you were too late and the wait handler has already been executed, or will soon be executed. If it returns 1 then the wait handler was successfully cancelled.
+
+
+* If a wait handler is cancelled, the boost::system::error\_code passed to it contains the value `boost::asio::error::operation_aborted`. 
+
+
+
+
+[heading Requirements]
+
+['Header: ][^boost/asio/basic_deadline_timer.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
 [section:basic_io_object basic_io_object]
 
 
@@ -14726,10 +14988,10 @@ Start an asynchronous connect.
 
 
   template<
-      typename ``[link boost_asio.reference.ConnectHandler ConnectHandler]``>
+      typename ``[link boost_asio.reference.ConnectHandler ConnectHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
       const endpoint_type & peer_endpoint,
-      ConnectHandler && handler);
+      ConnectHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously connect a socket to the specified remote endpoint. The function call always returns immediately.
@@ -14791,19 +15053,19 @@ Start an asynchronous receive on a connected socket.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_raw_socket.async_receive.overload1 async_receive]``(
       const MutableBufferSequence & buffers,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_raw_socket.async_receive.overload1 more...]]``
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_raw_socket.async_receive.overload2 async_receive]``(
       const MutableBufferSequence & buffers,
       socket_base::message_flags flags,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_raw_socket.async_receive.overload2 more...]]``
 
 
@@ -14815,10 +15077,10 @@ Start an asynchronous receive on a connected socket.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive(
       const MutableBufferSequence & buffers,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously receive data from the raw socket. The function call always returns immediately.
@@ -14872,11 +15134,11 @@ Start an asynchronous receive on a connected socket.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive(
       const MutableBufferSequence & buffers,
       socket_base::message_flags flags,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously receive data from the raw socket. The function call always returns immediately.
@@ -14923,21 +15185,21 @@ Start an asynchronous receive.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_raw_socket.async_receive_from.overload1 async_receive_from]``(
       const MutableBufferSequence & buffers,
       endpoint_type & sender_endpoint,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_raw_socket.async_receive_from.overload1 more...]]``
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_raw_socket.async_receive_from.overload2 async_receive_from]``(
       const MutableBufferSequence & buffers,
       endpoint_type & sender_endpoint,
       socket_base::message_flags flags,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_raw_socket.async_receive_from.overload2 more...]]``
 
 
@@ -14949,11 +15211,11 @@ Start an asynchronous receive.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive_from(
       const MutableBufferSequence & buffers,
       endpoint_type & sender_endpoint,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously receive raw data. The function call always returns immediately.
@@ -15005,12 +15267,12 @@ Start an asynchronous receive.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive_from(
       const MutableBufferSequence & buffers,
       endpoint_type & sender_endpoint,
       socket_base::message_flags flags,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously receive raw data. The function call always returns immediately.
@@ -15054,19 +15316,19 @@ Start an asynchronous send on a connected socket.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_raw_socket.async_send.overload1 async_send]``(
       const ConstBufferSequence & buffers,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_raw_socket.async_send.overload1 more...]]``
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_raw_socket.async_send.overload2 async_send]``(
       const ConstBufferSequence & buffers,
       socket_base::message_flags flags,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_raw_socket.async_send.overload2 more...]]``
 
 
@@ -15078,10 +15340,10 @@ Start an asynchronous send on a connected socket.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send(
       const ConstBufferSequence & buffers,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 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.
@@ -15135,11 +15397,11 @@ Start an asynchronous send on a connected socket.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send(
       const ConstBufferSequence & buffers,
       socket_base::message_flags flags,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 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.
@@ -15186,21 +15448,21 @@ Start an asynchronous send.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_raw_socket.async_send_to.overload1 async_send_to]``(
       const ConstBufferSequence & buffers,
       const endpoint_type & destination,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_raw_socket.async_send_to.overload1 more...]]``
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_raw_socket.async_send_to.overload2 async_send_to]``(
       const ConstBufferSequence & buffers,
       const endpoint_type & destination,
       socket_base::message_flags flags,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_raw_socket.async_send_to.overload2 more...]]``
 
 
@@ -15212,11 +15474,11 @@ Start an asynchronous send.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send_to(
       const ConstBufferSequence & buffers,
       const endpoint_type & destination,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously send raw data to the specified remote endpoint. The function call always returns immediately.
@@ -15270,12 +15532,12 @@ Start an asynchronous send.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send_to(
       const ConstBufferSequence & buffers,
       const endpoint_type & destination,
       socket_base::message_flags flags,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously send raw data to the specified remote endpoint. The function call always returns immediately.
@@ -15322,10 +15584,10 @@ Asynchronously wait for the socket to become ready to read, ready to write, or t
 
 
   template<
-      typename ``[link boost_asio.reference.WaitHandler WaitHandler]``>
+      typename ``[link boost_asio.reference.WaitHandler WaitHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
       wait_type w,
-      WaitHandler && handler);
+      WaitHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to perform an asynchronous wait for a socket to enter a ready to read, write or error condition state.
@@ -21454,10 +21716,10 @@ Start an asynchronous connect.
 
 
   template<
-      typename ``[link boost_asio.reference.ConnectHandler ConnectHandler]``>
+      typename ``[link boost_asio.reference.ConnectHandler ConnectHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
       const endpoint_type & peer_endpoint,
-      ConnectHandler && handler);
+      ConnectHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously connect a socket to the specified remote endpoint. The function call always returns immediately.
@@ -21519,21 +21781,21 @@ Start an asynchronous receive.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_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 boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_seq_packet_socket.async_receive.overload1 more...]]``
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_seq_packet_socket.async_receive.overload2 async_receive]``(
       const MutableBufferSequence & buffers,
       socket_base::message_flags in_flags,
       socket_base::message_flags & out_flags,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_seq_packet_socket.async_receive.overload2 more...]]``
 
 
@@ -21545,11 +21807,11 @@ Start an asynchronous receive.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive(
       const MutableBufferSequence & buffers,
       socket_base::message_flags & out_flags,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously receive data from the sequenced packet socket. The function call always returns immediately.
@@ -21600,12 +21862,12 @@ Start an asynchronous receive.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive(
       const MutableBufferSequence & buffers,
       socket_base::message_flags in_flags,
       socket_base::message_flags & out_flags,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously receive data from the sequenced data socket. The function call always returns immediately.
@@ -21662,11 +21924,11 @@ Start an asynchronous send.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send(
       const ConstBufferSequence & buffers,
       socket_base::message_flags flags,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously send data on the sequenced packet socket. The function call always returns immediately.
@@ -21719,10 +21981,10 @@ Asynchronously wait for the socket to become ready to read, ready to write, or t
 
 
   template<
-      typename ``[link boost_asio.reference.WaitHandler WaitHandler]``>
+      typename ``[link boost_asio.reference.WaitHandler WaitHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
       wait_type w,
-      WaitHandler && handler);
+      WaitHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to perform an asynchronous wait for a socket to enter a ready to read, write or error condition state.
@@ -26943,6 +27205,13 @@ Provides serial port functionality.
 
   [
 
+    [[link boost_asio.reference.basic_serial_port__rebind_executor [*rebind_executor]]]
+    [Rebinds the serial port type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.basic_serial_port.executor_type [*executor_type]]]
     [The type of the executor associated with the object. ]
   
@@ -27142,10 +27411,10 @@ Start an asynchronous read.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some(
       const MutableBufferSequence & buffers,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously read data from the serial port. The function call always returns immediately.
@@ -27200,10 +27469,10 @@ Start an asynchronous write.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some(
       const ConstBufferSequence & buffers,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously write data to the serial port. The function call always returns immediately.
@@ -28010,6 +28279,13 @@ A basic\_basic\_serial\_port is always the lowest layer.
 
   [
 
+    [[link boost_asio.reference.basic_serial_port__rebind_executor [*rebind_executor]]]
+    [Rebinds the serial port type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.basic_serial_port.executor_type [*executor_type]]]
     [The type of the executor associated with the object. ]
   
@@ -28757,6 +29033,209 @@ This function destroys the serial port, cancelling any outstanding asynchronous
 
 [endsect]
 
+[section:basic_serial_port__rebind_executor basic_serial_port::rebind_executor]
+
+
+Rebinds the serial port type to another executor. 
+
+
+  template<
+      typename ``[link boost_asio.reference.Executor1 Executor1]``>
+  struct rebind_executor
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.basic_serial_port__rebind_executor.other [*other]]]
+    [The serial port type when rebound to the specified executor. ]
+  
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^boost/asio/basic_serial_port.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[section:other basic_serial_port::rebind_executor::other]
+
+[indexterm2 boost_asio.indexterm.basic_serial_port__rebind_executor.other..other..basic_serial_port::rebind_executor] 
+The serial port type when rebound to the specified executor. 
+
+
+  typedef basic_serial_port< Executor1 > other;
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.basic_serial_port__rebind_executor [*rebind_executor]]]
+    [Rebinds the serial port type to another executor. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_serial_port.executor_type [*executor_type]]]
+    [The type of the executor associated with the object. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_serial_port.lowest_layer_type [*lowest_layer_type]]]
+    [A basic_basic_serial_port is always the lowest layer. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_serial_port.native_handle_type [*native_handle_type]]]
+    [The native representation of a serial port. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.basic_serial_port.assign [*assign]]]
+    [Assign an existing native serial port to the serial port. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_serial_port.async_read_some [*async_read_some]]]
+    [Start an asynchronous read. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_serial_port.async_write_some [*async_write_some]]]
+    [Start an asynchronous write. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_serial_port.basic_serial_port [*basic_serial_port]]]
+    [Construct a basic_serial_port without opening it. 
+     [hr]
+     Construct and open a basic_serial_port. 
+     [hr]
+     Construct a basic_serial_port on an existing native serial port. 
+     [hr]
+     Move-construct a basic_serial_port from another. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_serial_port.cancel [*cancel]]]
+    [Cancel all asynchronous operations associated with the serial port. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_serial_port.close [*close]]]
+    [Close the serial port. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_serial_port.get_executor [*get_executor]]]
+    [Get the executor associated with the object. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_serial_port.get_option [*get_option]]]
+    [Get an option from the serial port. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_serial_port.is_open [*is_open]]]
+    [Determine whether the serial port is open. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_serial_port.lowest_layer [*lowest_layer]]]
+    [Get a reference to the lowest layer. 
+     [hr]
+     Get a const reference to the lowest layer. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_serial_port.native_handle [*native_handle]]]
+    [Get the native serial port representation. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_serial_port.open [*open]]]
+    [Open the serial port using the specified device name. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_serial_port.operator_eq_ [*operator=]]]
+    [Move-assign a basic_serial_port from another. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_serial_port.read_some [*read_some]]]
+    [Read some data from the serial port. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_serial_port.send_break [*send_break]]]
+    [Send a break sequence to the serial port. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_serial_port.set_option [*set_option]]]
+    [Set an option on the serial port. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_serial_port.write_some [*write_some]]]
+    [Write some data to the serial port. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_serial_port._basic_serial_port [*~basic_serial_port]]]
+    [Destroys the serial port. ]
+  ]
+  
+]
+
+The [link boost_asio.reference.basic_serial_port `basic_serial_port`] class provides a wrapper over serial port functionality.
+
+
+[heading Thread Safety]
+  
+['Distinct] ['objects:] Safe.
+
+['Shared] ['objects:] Unsafe. 
+
+
+
+
+[heading Requirements]
+
+['Header: ][^boost/asio/basic_serial_port.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
 [section:basic_signal_set basic_signal_set]
 
 
@@ -28774,6 +29253,13 @@ Provides signal functionality.
 
   [
 
+    [[link boost_asio.reference.basic_signal_set__rebind_executor [*rebind_executor]]]
+    [Rebinds the signal set type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.basic_signal_set.executor_type [*executor_type]]]
     [The type of the executor associated with the object. ]
   
@@ -28995,9 +29481,9 @@ Start an asynchronous operation to wait for a signal to be delivered.
 
 
   template<
-      typename ``[link boost_asio.reference.SignalHandler SignalHandler]``>
+      typename ``[link boost_asio.reference.SignalHandler SignalHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
-      SignalHandler && handler);
+      SignalHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function may be used to initiate an asynchronous wait against the signal set. It always returns immediately.
@@ -29793,6 +30279,192 @@ This function destroys the signal set, cancelling any outstanding asynchronous w
 
 [endsect]
 
+[section:basic_signal_set__rebind_executor basic_signal_set::rebind_executor]
+
+
+Rebinds the signal set type to another executor. 
+
+
+  template<
+      typename ``[link boost_asio.reference.Executor1 Executor1]``>
+  struct rebind_executor
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.basic_signal_set__rebind_executor.other [*other]]]
+    [The signal set type when rebound to the specified executor. ]
+  
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^boost/asio/basic_signal_set.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[section:other basic_signal_set::rebind_executor::other]
+
+[indexterm2 boost_asio.indexterm.basic_signal_set__rebind_executor.other..other..basic_signal_set::rebind_executor] 
+The signal set type when rebound to the specified executor. 
+
+
+  typedef basic_signal_set< Executor1 > other;
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.basic_signal_set__rebind_executor [*rebind_executor]]]
+    [Rebinds the signal set type to another executor. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_signal_set.executor_type [*executor_type]]]
+    [The type of the executor associated with the object. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.basic_signal_set.add [*add]]]
+    [Add a signal to a signal_set. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_signal_set.async_wait [*async_wait]]]
+    [Start an asynchronous operation to wait for a signal to be delivered. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_signal_set.basic_signal_set [*basic_signal_set]]]
+    [Construct a signal set without adding any signals. 
+     [hr]
+     Construct a signal set and add one signal. 
+     [hr]
+     Construct a signal set and add two signals. 
+     [hr]
+     Construct a signal set and add three signals. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_signal_set.cancel [*cancel]]]
+    [Cancel all operations associated with the signal set. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_signal_set.clear [*clear]]]
+    [Remove all signals from a signal_set. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_signal_set.get_executor [*get_executor]]]
+    [Get the executor associated with the object. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_signal_set.remove [*remove]]]
+    [Remove a signal from a signal_set. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_signal_set._basic_signal_set [*~basic_signal_set]]]
+    [Destroys the signal set. ]
+  ]
+  
+]
+
+The [link boost_asio.reference.basic_signal_set `basic_signal_set`] class provides the ability to perform an asynchronous wait for one or more signals to occur.
+
+
+[heading Thread Safety]
+  
+['Distinct] ['objects:] Safe.
+
+['Shared] ['objects:] Unsafe.
+
+
+[heading Example]
+  
+Performing an asynchronous wait: 
+
+   void handler(
+       const boost::system::error_code& error,
+       int signal_number)
+   {
+     if (!error)
+     {
+       // A signal occurred.
+     }
+   }
+
+   ...
+
+   // Construct a signal set registered for process termination.
+   boost::asio::signal_set signals(my_context, SIGINT, SIGTERM);
+
+   // Start an asynchronous wait for one of the signals to occur.
+   signals.async_wait(handler);
+
+
+
+
+
+[heading Queueing of signal notifications]
+  
+
+
+If a signal is registered with a signal\_set, and the signal occurs when there are no waiting handlers, then the signal notification is queued. The next async\_wait operation on that signal\_set will dequeue the notification. If multiple notifications are queued, subsequent async\_wait operations dequeue them one at a time. Signal notifications are dequeued in order of ascending signal number.
+
+If a signal number is removed from a signal\_set (using the `remove` or `erase` member functions) then any queued notifications for that signal are discarded.
+
+
+[heading Multiple registration of signals]
+  
+
+
+The same signal number may be registered with different signal\_set objects. When the signal occurs, one handler is called for each signal\_set object.
+
+Note that multiple registration only works for signals that are registered using Asio. The application must not also register a signal handler using functions such as `signal()` or `sigaction()`.
+
+
+[heading Signal masking on POSIX platforms]
+  
+
+
+POSIX allows signals to be blocked using functions such as `sigprocmask()` and `pthread_sigmask()`. For signals to be delivered, programs must ensure that any signals registered using signal\_set objects are unblocked in at least one thread. 
+
+
+[heading Requirements]
+
+['Header: ][^boost/asio/basic_signal_set.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
 [section:basic_socket basic_socket]
 
 
@@ -30255,10 +30927,10 @@ Start an asynchronous connect.
 
 
   template<
-      typename ``[link boost_asio.reference.ConnectHandler ConnectHandler]``>
+      typename ``[link boost_asio.reference.ConnectHandler ConnectHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
       const endpoint_type & peer_endpoint,
-      ConnectHandler && handler);
+      ConnectHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously connect a socket to the specified remote endpoint. The function call always returns immediately.
@@ -30320,10 +30992,10 @@ Asynchronously wait for the socket to become ready to read, ready to write, or t
 
 
   template<
-      typename ``[link boost_asio.reference.WaitHandler WaitHandler]``>
+      typename ``[link boost_asio.reference.WaitHandler WaitHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
       wait_type w,
-      WaitHandler && handler);
+      WaitHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to perform an asynchronous wait for a socket to enter a ready to read, write or error condition state.
@@ -35059,6 +35731,13 @@ Provides the ability to accept new connections.
 
   [
 
+    [[link boost_asio.reference.basic_socket_acceptor__rebind_executor [*rebind_executor]]]
+    [Rebinds the acceptor type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.basic_socket_acceptor.broadcast [*broadcast]]]
     [Socket option to permit sending of broadcast messages. ]
   
@@ -35448,10 +36127,10 @@ Accept a new connection and obtain the endpoint of the peer.
       boost::system::error_code & ec);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_socket_acceptor.accept.overload4 more...]]``
 
-  Protocol::socket ``[link boost_asio.reference.basic_socket_acceptor.accept.overload5 accept]``();
+  Protocol::socket::template rebind_executor< executor_type >::other ``[link boost_asio.reference.basic_socket_acceptor.accept.overload5 accept]``();
   ``  [''''&raquo;''' [link boost_asio.reference.basic_socket_acceptor.accept.overload5 more...]]``
 
-  Protocol::socket ``[link boost_asio.reference.basic_socket_acceptor.accept.overload6 accept]``(
+  Protocol::socket::template rebind_executor< executor_type >::other ``[link boost_asio.reference.basic_socket_acceptor.accept.overload6 accept]``(
       boost::system::error_code & ec);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_socket_acceptor.accept.overload6 more...]]``
 
@@ -35485,11 +36164,11 @@ Accept a new connection and obtain the endpoint of the peer.
       typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_socket_acceptor.accept.overload10 more...]]``
 
-  Protocol::socket ``[link boost_asio.reference.basic_socket_acceptor.accept.overload11 accept]``(
+  Protocol::socket::template rebind_executor< executor_type >::other ``[link boost_asio.reference.basic_socket_acceptor.accept.overload11 accept]``(
       endpoint_type & peer_endpoint);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_socket_acceptor.accept.overload11 more...]]``
 
-  Protocol::socket ``[link boost_asio.reference.basic_socket_acceptor.accept.overload12 accept]``(
+  Protocol::socket::template rebind_executor< executor_type >::other ``[link boost_asio.reference.basic_socket_acceptor.accept.overload12 accept]``(
       endpoint_type & peer_endpoint,
       boost::system::error_code & ec);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_socket_acceptor.accept.overload12 more...]]``
@@ -35759,7 +36438,7 @@ This function is used to accept a new connection from a peer into the given sock
 Accept a new connection. 
 
 
-  Protocol::socket accept();
+  Protocol::socket::template rebind_executor< executor_type >::other accept();
 
 
 This function is used to accept a new connection from a peer. The function call will block until a new connection has been accepted successfully or an error occurs.
@@ -35806,7 +36485,7 @@ A socket object representing the newly accepted connection.
 Accept a new connection. 
 
 
-  Protocol::socket accept(
+  Protocol::socket::template rebind_executor< executor_type >::other accept(
       boost::system::error_code & ec);
 
 
@@ -36096,7 +36775,7 @@ On success, a socket object representing the newly accepted connection. On error
 Accept a new connection. 
 
 
-  Protocol::socket accept(
+  Protocol::socket::template rebind_executor< executor_type >::other accept(
       endpoint_type & peer_endpoint);
 
 
@@ -36155,7 +36834,7 @@ A socket object representing the newly accepted connection.
 Accept a new connection. 
 
 
-  Protocol::socket accept(
+  Protocol::socket::template rebind_executor< executor_type >::other accept(
       endpoint_type & peer_endpoint,
       boost::system::error_code & ec);
 
@@ -36525,70 +37204,70 @@ Start an asynchronous accept.
   template<
       typename ``[link boost_asio.reference.Protocol Protocol1]``,
       typename ``[link boost_asio.reference.Executor1 Executor1]``,
-      typename ``[link boost_asio.reference.AcceptHandler AcceptHandler]``>
+      typename ``[link boost_asio.reference.AcceptHandler AcceptHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_socket_acceptor.async_accept.overload1 async_accept]``(
       basic_socket< Protocol1, Executor1 > & peer,
-      AcceptHandler && handler,
+      AcceptHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_convertible< Protocol, Protocol1 >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_socket_acceptor.async_accept.overload1 more...]]``
 
   template<
       typename ``[link boost_asio.reference.Executor1 Executor1]``,
-      typename ``[link boost_asio.reference.AcceptHandler AcceptHandler]``>
+      typename ``[link boost_asio.reference.AcceptHandler AcceptHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_socket_acceptor.async_accept.overload2 async_accept]``(
       basic_socket< protocol_type, Executor1 > & peer,
       endpoint_type & peer_endpoint,
-      AcceptHandler && handler);
+      AcceptHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_socket_acceptor.async_accept.overload2 more...]]``
 
   template<
-      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]``>
+      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_socket_acceptor.async_accept.overload3 async_accept]``(
-      MoveAcceptHandler && handler);
+      MoveAcceptHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_socket_acceptor.async_accept.overload3 more...]]``
 
   template<
       typename ``[link boost_asio.reference.Executor1 Executor1]``,
-      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]``>
+      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_socket_acceptor.async_accept.overload4 async_accept]``(
       const Executor1 & ex,
-      MoveAcceptHandler && handler,
+      MoveAcceptHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_executor< Executor1 >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_socket_acceptor.async_accept.overload4 more...]]``
 
   template<
       typename ExecutionContext,
-      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]``>
+      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_socket_acceptor.async_accept.overload5 async_accept]``(
       ExecutionContext & context,
-      MoveAcceptHandler && handler,
+      MoveAcceptHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_socket_acceptor.async_accept.overload5 more...]]``
 
   template<
-      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]``>
+      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_socket_acceptor.async_accept.overload6 async_accept]``(
       endpoint_type & peer_endpoint,
-      MoveAcceptHandler && handler);
+      MoveAcceptHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_socket_acceptor.async_accept.overload6 more...]]``
 
   template<
       typename ``[link boost_asio.reference.Executor1 Executor1]``,
-      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]``>
+      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_socket_acceptor.async_accept.overload7 async_accept]``(
       const Executor1 & ex,
       endpoint_type & peer_endpoint,
-      MoveAcceptHandler && handler,
+      MoveAcceptHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_executor< Executor1 >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_socket_acceptor.async_accept.overload7 more...]]``
 
   template<
       typename ExecutionContext,
-      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]``>
+      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_socket_acceptor.async_accept.overload8 async_accept]``(
       ExecutionContext & context,
       endpoint_type & peer_endpoint,
-      MoveAcceptHandler && handler,
+      MoveAcceptHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_socket_acceptor.async_accept.overload8 more...]]``
 
@@ -36602,10 +37281,10 @@ Start an asynchronous accept.
   template<
       typename ``[link boost_asio.reference.Protocol Protocol1]``,
       typename ``[link boost_asio.reference.Executor1 Executor1]``,
-      typename ``[link boost_asio.reference.AcceptHandler AcceptHandler]``>
+      typename ``[link boost_asio.reference.AcceptHandler AcceptHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_accept(
       basic_socket< Protocol1, Executor1 > & peer,
-      AcceptHandler && handler,
+      AcceptHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_convertible< Protocol, Protocol1 >::value >::type *  = 0);
 
 
@@ -36667,11 +37346,11 @@ Start an asynchronous accept.
 
   template<
       typename ``[link boost_asio.reference.Executor1 Executor1]``,
-      typename ``[link boost_asio.reference.AcceptHandler AcceptHandler]``>
+      typename ``[link boost_asio.reference.AcceptHandler AcceptHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_accept(
       basic_socket< protocol_type, Executor1 > & peer,
       endpoint_type & peer_endpoint,
-      AcceptHandler && handler);
+      AcceptHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 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.
@@ -36710,9 +37389,9 @@ Start an asynchronous accept.
 
 
   template<
-      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]``>
+      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_accept(
-      MoveAcceptHandler && handler);
+      MoveAcceptHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously accept a new connection. The function call always returns immediately.
@@ -36728,8 +37407,11 @@ This overload requires that the Protocol template parameter satisfy the Acceptab
 [[handler][The handler to be called when the accept operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
 ``
    void handler(
-     const boost::system::error_code& error, // Result of operation.
-     typename Protocol::socket peer // On success, the newly accepted socket.
+     // Result of operation.
+     const boost::system::error_code& error,
+     // On success, the newly accepted socket.
+     typename Protocol::socket::template
+       rebind_executor<executor_type>::other peer
    ); 
 ``
 Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link boost_asio.reference.post `post`].]]
@@ -36774,10 +37456,10 @@ Start an asynchronous accept.
 
   template<
       typename ``[link boost_asio.reference.Executor1 Executor1]``,
-      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]``>
+      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_accept(
       const Executor1 & ex,
-      MoveAcceptHandler && handler,
+      MoveAcceptHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_executor< Executor1 >::value >::type *  = 0);
 
 
@@ -36843,10 +37525,10 @@ Start an asynchronous accept.
 
   template<
       typename ExecutionContext,
-      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]``>
+      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_accept(
       ExecutionContext & context,
-      MoveAcceptHandler && handler,
+      MoveAcceptHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type *  = 0);
 
 
@@ -36912,10 +37594,10 @@ Start an asynchronous accept.
 
 
   template<
-      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]``>
+      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_accept(
       endpoint_type & peer_endpoint,
-      MoveAcceptHandler && handler);
+      MoveAcceptHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously accept a new connection. The function call always returns immediately.
@@ -36933,8 +37615,11 @@ This overload requires that the Protocol template parameter satisfy the Acceptab
 [[handler][The handler to be called when the accept operation completes. Copies will be made of the handler as required. The function signature of the handler must be: 
 ``
    void handler(
-     const boost::system::error_code& error, // Result of operation.
-     typename Protocol::socket peer // On success, the newly accepted socket.
+     // Result of operation.
+     const boost::system::error_code& error,
+     // On success, the newly accepted socket.
+     typename Protocol::socket::template
+       rebind_executor<executor_type>::other peer
    ); 
 ``
 Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link boost_asio.reference.post `post`].]]
@@ -36980,11 +37665,11 @@ Start an asynchronous accept.
 
   template<
       typename ``[link boost_asio.reference.Executor1 Executor1]``,
-      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]``>
+      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_accept(
       const Executor1 & ex,
       endpoint_type & peer_endpoint,
-      MoveAcceptHandler && handler,
+      MoveAcceptHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_executor< Executor1 >::value >::type *  = 0);
 
 
@@ -37053,11 +37738,11 @@ Start an asynchronous accept.
 
   template<
       typename ExecutionContext,
-      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]``>
+      typename ``[link boost_asio.reference.MoveAcceptHandler MoveAcceptHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_accept(
       ExecutionContext & context,
       endpoint_type & peer_endpoint,
-      MoveAcceptHandler && handler,
+      MoveAcceptHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type *  = 0);
 
 
@@ -37128,10 +37813,10 @@ Asynchronously wait for the acceptor to become ready to read, ready to write, or
 
 
   template<
-      typename ``[link boost_asio.reference.WaitHandler WaitHandler]``>
+      typename ``[link boost_asio.reference.WaitHandler WaitHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
       wait_type w,
-      WaitHandler && handler);
+      WaitHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to perform an asynchronous wait for an acceptor to enter a ready to read, write or error condition state.
@@ -40296,6 +40981,414 @@ This function destroys the acceptor, cancelling any outstanding asynchronous ope
 
 [endsect]
 
+[section:basic_socket_acceptor__rebind_executor basic_socket_acceptor::rebind_executor]
+
+
+Rebinds the acceptor type to another executor. 
+
+
+  template<
+      typename ``[link boost_asio.reference.Executor1 Executor1]``>
+  struct rebind_executor
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor__rebind_executor.other [*other]]]
+    [The socket type when rebound to the specified executor. ]
+  
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^boost/asio/basic_socket_acceptor.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[section:other basic_socket_acceptor::rebind_executor::other]
+
+[indexterm2 boost_asio.indexterm.basic_socket_acceptor__rebind_executor.other..other..basic_socket_acceptor::rebind_executor] 
+The socket type when rebound to the specified executor. 
+
+
+  typedef basic_socket_acceptor< Protocol, Executor1 > other;
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor__rebind_executor [*rebind_executor]]]
+    [Rebinds the acceptor type to another executor. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor.broadcast [*broadcast]]]
+    [Socket option to permit sending of broadcast messages. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor.bytes_readable [*bytes_readable]]]
+    [IO control command to get the amount of data that can be read without blocking. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor.debug [*debug]]]
+    [Socket option to enable socket-level debugging. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor.do_not_route [*do_not_route]]]
+    [Socket option to prevent routing, use local interfaces only. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor.enable_connection_aborted [*enable_connection_aborted]]]
+    [Socket option to report aborted connections on accept. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor.endpoint_type [*endpoint_type]]]
+    [The endpoint type. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor.executor_type [*executor_type]]]
+    [The type of the executor associated with the object. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor.keep_alive [*keep_alive]]]
+    [Socket option to send keep-alives. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor.linger [*linger]]]
+    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor.message_flags [*message_flags]]]
+    [Bitmask type for flags that can be passed to send and receive operations. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor.native_handle_type [*native_handle_type]]]
+    [The native representation of an acceptor. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor.out_of_band_inline [*out_of_band_inline]]]
+    [Socket option for putting received out-of-band data inline. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor.protocol_type [*protocol_type]]]
+    [The protocol type. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor.receive_buffer_size [*receive_buffer_size]]]
+    [Socket option for the receive buffer size of a socket. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor.receive_low_watermark [*receive_low_watermark]]]
+    [Socket option for the receive low watermark. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor.reuse_address [*reuse_address]]]
+    [Socket option to allow the socket to be bound to an address that is already in use. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor.send_buffer_size [*send_buffer_size]]]
+    [Socket option for the send buffer size of a socket. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor.send_low_watermark [*send_low_watermark]]]
+    [Socket option for the send low watermark. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor.shutdown_type [*shutdown_type]]]
+    [Different ways a socket may be shutdown. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_socket_acceptor.wait_type [*wait_type]]]
+    [Wait types. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.accept [*accept]]]
+    [Accept a new connection. 
+     [hr]
+     Accept a new connection and obtain the endpoint of the peer. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.assign [*assign]]]
+    [Assigns an existing native acceptor to the acceptor. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.async_accept [*async_accept]]]
+    [Start an asynchronous accept. ]
+  ]
+  
+  [
+    [[link boost_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 boost_asio.reference.basic_socket_acceptor.basic_socket_acceptor [*basic_socket_acceptor]]]
+    [Construct an acceptor without opening it. 
+     [hr]
+     Construct an open acceptor. 
+     [hr]
+     Construct an acceptor opened on the given endpoint. 
+     [hr]
+     Construct a basic_socket_acceptor on an existing native acceptor. 
+     [hr]
+     Move-construct a basic_socket_acceptor from another. 
+     [hr]
+     Move-construct a basic_socket_acceptor from an acceptor of another protocol type. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.bind [*bind]]]
+    [Bind the acceptor to the given local endpoint. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.cancel [*cancel]]]
+    [Cancel all asynchronous operations associated with the acceptor. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.close [*close]]]
+    [Close the acceptor. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.get_executor [*get_executor]]]
+    [Get the executor associated with the object. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.get_option [*get_option]]]
+    [Get an option from the acceptor. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.io_control [*io_control]]]
+    [Perform an IO control command on the acceptor. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.is_open [*is_open]]]
+    [Determine whether the acceptor is open. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.listen [*listen]]]
+    [Place the acceptor into the state where it will listen for new connections. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.local_endpoint [*local_endpoint]]]
+    [Get the local endpoint of the acceptor. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.native_handle [*native_handle]]]
+    [Get the native acceptor representation. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.native_non_blocking [*native_non_blocking]]]
+    [Gets the non-blocking mode of the native acceptor implementation. 
+     [hr]
+     Sets the non-blocking mode of the native acceptor implementation. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.non_blocking [*non_blocking]]]
+    [Gets the non-blocking mode of the acceptor. 
+     [hr]
+     Sets the non-blocking mode of the acceptor. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.open [*open]]]
+    [Open the acceptor using the specified protocol. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.operator_eq_ [*operator=]]]
+    [Move-assign a basic_socket_acceptor from another. 
+     [hr]
+     Move-assign a basic_socket_acceptor from an acceptor of another protocol type. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.release [*release]]]
+    [Release ownership of the underlying native acceptor. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.set_option [*set_option]]]
+    [Set an option on the acceptor. ]
+  ]
+  
+  [
+    [[link boost_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. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_socket_acceptor._basic_socket_acceptor [*~basic_socket_acceptor]]]
+    [Destroys the acceptor. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.max_connections [*max_connections]]]
+    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
+  ]
+
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.max_listen_connections [*max_listen_connections]]]
+    [The maximum length of the queue of pending incoming connections. ]
+  ]
+
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.message_do_not_route [*message_do_not_route]]]
+    [Specify that the data should not be subject to routing. ]
+  ]
+
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.message_end_of_record [*message_end_of_record]]]
+    [Specifies that the data marks the end of a record. ]
+  ]
+
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.message_out_of_band [*message_out_of_band]]]
+    [Process out-of-band data. ]
+  ]
+
+  [
+    [[link boost_asio.reference.basic_socket_acceptor.message_peek [*message_peek]]]
+    [Peek at incoming data without removing it from the input queue. ]
+  ]
+
+]
+
+The [link boost_asio.reference.basic_socket_acceptor `basic_socket_acceptor`] class template is used for accepting new socket connections.
+
+
+[heading Thread Safety]
+  
+['Distinct] ['objects:] Safe.
+
+['Shared] ['objects:] Unsafe.
+
+
+[heading Example]
+  
+Opening a socket acceptor with the SO\_REUSEADDR option enabled: 
+
+   boost::asio::ip::tcp::acceptor acceptor(my_context);
+   boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), port);
+   acceptor.open(endpoint.protocol());
+   acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
+   acceptor.bind(endpoint);
+   acceptor.listen();
+
+
+
+
+
+
+
+[heading Requirements]
+
+['Header: ][^boost/asio/basic_socket_acceptor.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
 [section:basic_socket_iostream basic_socket_iostream]
 
 
@@ -42327,10 +43420,10 @@ Start an asynchronous connect.
 
 
   template<
-      typename ``[link boost_asio.reference.ConnectHandler ConnectHandler]``>
+      typename ``[link boost_asio.reference.ConnectHandler ConnectHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
       const endpoint_type & peer_endpoint,
-      ConnectHandler && handler);
+      ConnectHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously connect a socket to the specified remote endpoint. The function call always returns immediately.
@@ -42393,10 +43486,10 @@ Start an asynchronous read.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some(
       const MutableBufferSequence & buffers,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously read data from the stream socket. The function call always returns immediately.
@@ -42449,19 +43542,19 @@ Start an asynchronous receive.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_stream_socket.async_receive.overload1 async_receive]``(
       const MutableBufferSequence & buffers,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_stream_socket.async_receive.overload1 more...]]``
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_stream_socket.async_receive.overload2 async_receive]``(
       const MutableBufferSequence & buffers,
       socket_base::message_flags flags,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_stream_socket.async_receive.overload2 more...]]``
 
 
@@ -42473,10 +43566,10 @@ Start an asynchronous receive.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive(
       const MutableBufferSequence & buffers,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously receive data from the stream socket. The function call always returns immediately.
@@ -42530,11 +43623,11 @@ Start an asynchronous receive.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive(
       const MutableBufferSequence & buffers,
       socket_base::message_flags flags,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously receive data from the stream socket. The function call always returns immediately.
@@ -42591,19 +43684,19 @@ Start an asynchronous send.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_stream_socket.async_send.overload1 async_send]``(
       const ConstBufferSequence & buffers,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_stream_socket.async_send.overload1 more...]]``
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.basic_stream_socket.async_send.overload2 async_send]``(
       const ConstBufferSequence & buffers,
       socket_base::message_flags flags,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.basic_stream_socket.async_send.overload2 more...]]``
 
 
@@ -42615,10 +43708,10 @@ Start an asynchronous send.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send(
       const ConstBufferSequence & buffers,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously send data on the stream socket. The function call always returns immediately.
@@ -42672,11 +43765,11 @@ Start an asynchronous send.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send(
       const ConstBufferSequence & buffers,
       socket_base::message_flags flags,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously send data on the stream socket. The function call always returns immediately.
@@ -42736,10 +43829,10 @@ Asynchronously wait for the socket to become ready to read, ready to write, or t
 
 
   template<
-      typename ``[link boost_asio.reference.WaitHandler WaitHandler]``>
+      typename ``[link boost_asio.reference.WaitHandler WaitHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
       wait_type w,
-      WaitHandler && handler);
+      WaitHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to perform an asynchronous wait for a socket to enter a ready to read, write or error condition state.
@@ -42799,10 +43892,10 @@ Start an asynchronous write.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some(
       const ConstBufferSequence & buffers,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously write data to the stream socket. The function call always returns immediately.
@@ -49414,6 +50507,13 @@ Provides waitable timer functionality.
 
   [
 
+    [[link boost_asio.reference.basic_waitable_timer__rebind_executor [*rebind_executor]]]
+    [Rebinds the timer type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.basic_waitable_timer.clock_type [*clock_type]]]
     [The clock type. ]
   
@@ -49644,9 +50744,9 @@ Start an asynchronous wait on the timer.
 
 
   template<
-      typename ``[link boost_asio.reference.WaitHandler WaitHandler]``>
+      typename ``[link boost_asio.reference.WaitHandler WaitHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
-      WaitHandler && handler);
+      WaitHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function may be used to initiate an asynchronous wait against the timer. It always returns immediately.
@@ -50800,6 +51900,289 @@ This function destroys the timer, cancelling any outstanding asynchronous wait o
 
 [endsect]
 
+[section:basic_waitable_timer__rebind_executor basic_waitable_timer::rebind_executor]
+
+
+Rebinds the timer type to another executor. 
+
+
+  template<
+      typename ``[link boost_asio.reference.Executor1 Executor1]``>
+  struct rebind_executor
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.basic_waitable_timer__rebind_executor.other [*other]]]
+    [The timer type when rebound to the specified executor. ]
+  
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^boost/asio/basic_waitable_timer.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[section:other basic_waitable_timer::rebind_executor::other]
+
+[indexterm2 boost_asio.indexterm.basic_waitable_timer__rebind_executor.other..other..basic_waitable_timer::rebind_executor] 
+The timer type when rebound to the specified executor. 
+
+
+  typedef basic_waitable_timer< Clock, WaitTraits, Executor1 > other;
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.basic_waitable_timer__rebind_executor [*rebind_executor]]]
+    [Rebinds the timer type to another executor. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_waitable_timer.clock_type [*clock_type]]]
+    [The clock type. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_waitable_timer.duration [*duration]]]
+    [The duration type of the clock. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_waitable_timer.executor_type [*executor_type]]]
+    [The type of the executor associated with the object. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_waitable_timer.time_point [*time_point]]]
+    [The time point type of the clock. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.basic_waitable_timer.traits_type [*traits_type]]]
+    [The wait traits type. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.basic_waitable_timer.async_wait [*async_wait]]]
+    [Start an asynchronous wait on the timer. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_waitable_timer.basic_waitable_timer [*basic_waitable_timer]]]
+    [Constructor. 
+     [hr]
+     Constructor to set a particular expiry time as an absolute time. 
+     [hr]
+     Constructor to set a particular expiry time relative to now. 
+     [hr]
+     Move-construct a basic_waitable_timer from another. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_waitable_timer.cancel [*cancel]]]
+    [Cancel any asynchronous operations that are waiting on the timer. 
+     [hr]
+     (Deprecated: Use non-error_code overload.) Cancel any asynchronous operations that are waiting on the timer. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_waitable_timer.cancel_one [*cancel_one]]]
+    [Cancels one asynchronous operation that is waiting on the timer. 
+     [hr]
+     (Deprecated: Use non-error_code overload.) Cancels one asynchronous operation that is waiting on the timer. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_waitable_timer.expires_after [*expires_after]]]
+    [Set the timer's expiry time relative to now. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_waitable_timer.expires_at [*expires_at]]]
+    [(Deprecated: Use expiry().) Get the timer's expiry time as an absolute time. 
+     [hr]
+     Set the timer's expiry time as an absolute time. 
+     [hr]
+     (Deprecated: Use non-error_code overload.) Set the timer's expiry time as an absolute time. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_waitable_timer.expires_from_now [*expires_from_now]]]
+    [(Deprecated: Use expiry().) Get the timer's expiry time relative to now. 
+     [hr]
+     (Deprecated: Use expires_after().) Set the timer's expiry time relative to now. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_waitable_timer.expiry [*expiry]]]
+    [Get the timer's expiry time as an absolute time. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_waitable_timer.get_executor [*get_executor]]]
+    [Get the executor associated with the object. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_waitable_timer.operator_eq_ [*operator=]]]
+    [Move-assign a basic_waitable_timer from another. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_waitable_timer.wait [*wait]]]
+    [Perform a blocking wait on the timer. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.basic_waitable_timer._basic_waitable_timer [*~basic_waitable_timer]]]
+    [Destroys the timer. ]
+  ]
+  
+]
+
+The [link boost_asio.reference.basic_waitable_timer `basic_waitable_timer`] class template provides the ability to perform a blocking or asynchronous wait for a timer to expire.
+
+A waitable timer is always in one of two states: "expired" or "not expired". If the `wait()` or `async_wait()` function is called on an expired timer, the wait operation will complete immediately.
+
+Most applications will use one of the [link boost_asio.reference.steady_timer `steady_timer`], [link boost_asio.reference.system_timer `system_timer`] or [link boost_asio.reference.high_resolution_timer `high_resolution_timer`] typedefs.
+
+
+[heading Remarks]
+      
+This waitable timer functionality is for use with the C++11 standard library's `<chrono>` facility, or with the Boost.Chrono library.
+
+
+[heading Thread Safety]
+  
+['Distinct] ['objects:] Safe.
+
+['Shared] ['objects:] Unsafe.
+
+
+[heading Examples]
+  
+Performing a blocking wait (C++11): 
+
+   // Construct a timer without setting an expiry time.
+   boost::asio::steady_timer timer(my_context);
+
+   // Set an expiry time relative to now.
+   timer.expires_after(std::chrono::seconds(5));
+
+   // Wait for the timer to expire.
+   timer.wait();
+
+
+
+
+
+Performing an asynchronous wait (C++11): 
+
+   void handler(const boost::system::error_code& error)
+   {
+     if (!error)
+     {
+       // Timer expired.
+     }
+   }
+
+   ...
+
+   // Construct a timer with an absolute expiry time.
+   boost::asio::steady_timer timer(my_context,
+       std::chrono::steady_clock::now() + std::chrono::seconds(60));
+
+   // Start an asynchronous wait.
+   timer.async_wait(handler);
+
+
+
+
+
+[heading Changing an active waitable timer's expiry time]
+  
+
+
+Changing the expiry time of a timer while there are pending asynchronous waits causes those wait operations to be cancelled. To ensure that the action associated with the timer is performed only once, use something like this: used:
+
+
+
+   void on_some_event()
+   {
+     if (my_timer.expires_after(seconds(5)) > 0)
+     {
+       // We managed to cancel the timer. Start new asynchronous wait.
+       my_timer.async_wait(on_timeout);
+     }
+     else
+     {
+       // Too late, timer has already expired!
+     }
+   }
+
+   void on_timeout(const boost::system::error_code& e)
+   {
+     if (e != boost::asio::error::operation_aborted)
+     {
+       // Timer was not cancelled, take necessary action.
+     }
+   }
+
+
+
+
+
+* The `boost::asio::basic_waitable_timer::expires_after()` function cancels any pending asynchronous waits, and returns the number of asynchronous waits that were cancelled. If it returns 0 then you were too late and the wait handler has already been executed, or will soon be executed. If it returns 1 then the wait handler was successfully cancelled.
+
+
+* If a wait handler is cancelled, the boost::system::error\_code passed to it contains the value `boost::asio::error::operation_aborted`. 
+
+
+
+
+[heading Requirements]
+
+['Header: ][^boost/asio/basic_waitable_timer.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
 [section:basic_yield_context basic_yield_context]
 
 
@@ -53253,9 +54636,9 @@ Start an asynchronous fill.
 
 
   template<
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_fill(
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 
@@ -53271,10 +54654,10 @@ Start an asynchronous read. The buffer into which the data will be read must be
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some(
       const MutableBufferSequence & buffers,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 
@@ -53290,10 +54673,10 @@ Start an asynchronous write. The data being written must be valid for the lifeti
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some(
       const ConstBufferSequence & buffers,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 
@@ -53984,9 +55367,9 @@ Start an asynchronous fill.
 
 
   template<
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_fill(
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 
@@ -54001,9 +55384,9 @@ Start an asynchronous flush.
 
 
   template<
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_flush(
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 
@@ -54019,10 +55402,10 @@ Start an asynchronous read. The buffer into which the data will be read must be
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some(
       const MutableBufferSequence & buffers,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 
@@ -54038,10 +55421,10 @@ Start an asynchronous write. The data being written must be valid for the lifeti
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some(
       const ConstBufferSequence & buffers,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 
@@ -54767,9 +56150,9 @@ Start an asynchronous flush.
 
 
   template<
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_flush(
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 
@@ -54785,10 +56168,10 @@ Start an asynchronous read. The buffer into which the data will be read must be
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some(
       const MutableBufferSequence & buffers,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 
@@ -54804,10 +56187,10 @@ Start an asynchronous write. The data being written must be valid for the lifeti
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some(
       const ConstBufferSequence & buffers,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 
@@ -56140,22 +57523,22 @@ Spawn a new thread of execution.
   template<
       typename ``[link boost_asio.reference.Executor1 Executor]``,
       typename F,
-      typename CompletionToken>
+      typename CompletionToken = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.co_spawn.overload1 co_spawn]``(
       const Executor & ex,
       F && f,
-      CompletionToken && token,
+      CompletionToken && token = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_executor< Executor >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.co_spawn.overload1 more...]]``
 
   template<
       typename ExecutionContext,
       typename F,
-      typename CompletionToken>
+      typename CompletionToken = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.co_spawn.overload2 co_spawn]``(
       ExecutionContext & ctx,
       F && f,
-      CompletionToken && token,
+      CompletionToken && token = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.co_spawn.overload2 more...]]``
 
@@ -56175,11 +57558,11 @@ Spawn a new thread of execution.
   template<
       typename ``[link boost_asio.reference.Executor1 Executor]``,
       typename F,
-      typename CompletionToken>
+      typename CompletionToken = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` co_spawn(
       const Executor & ex,
       F && f,
-      CompletionToken && token,
+      CompletionToken && token = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_executor< Executor >::value >::type *  = 0);
 
 
@@ -56208,11 +57591,11 @@ Spawn a new thread of execution.
   template<
       typename ExecutionContext,
       typename F,
-      typename CompletionToken>
+      typename CompletionToken = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` co_spawn(
       ExecutionContext & ctx,
       F && f,
-      CompletionToken && token,
+      CompletionToken && token = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type *  = 0);
 
 
@@ -58280,6 +59663,13 @@ Typedef for the typical usage of timer. Uses a UTC clock.
 
   [
 
+    [[link boost_asio.reference.basic_deadline_timer__rebind_executor [*rebind_executor]]]
+    [Rebinds the timer type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.basic_deadline_timer.duration_type [*duration_type]]]
     [The duration type. ]
   
@@ -58479,6 +59869,64 @@ Changing the expiry time of a timer while there are pending asynchronous waits c
 [endsect]
 
 
+[section:default_completion_token default_completion_token]
+
+
+Traits type used to determine the default completion token type associated with a type (such as an executor). 
+
+
+  template<
+      typename T>
+  struct default_completion_token
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.default_completion_token.type [*type]]]
+    [If T has a nested type default_completion_token_type, T::default_completion_token_type. Otherwise the typedef type is not defined. ]
+  
+  ]
+
+]
+
+A program may specialise this traits type if the `T` template parameter in the specialisation is a user-defined type.
+
+Specialisations of this trait may provide a nested typedef `type`, which is a default-constructible completion token type. 
+
+[heading Requirements]
+
+['Header: ][^boost/asio/async_result.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[section:type default_completion_token::type]
+
+[indexterm2 boost_asio.indexterm.default_completion_token.type..type..default_completion_token] 
+If `T` has a nested type `default_completion_token_type`, `T::default_completion_token_type`. Otherwise the typedef `type` is not defined. 
+
+
+  typedef see_below type;
+
+
+
+[heading Requirements]
+
+['Header: ][^boost/asio/async_result.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
 [section:defer defer]
 
 [indexterm1 boost_asio.indexterm.defer..defer] 
@@ -58492,19 +59940,19 @@ Submits a completion token or function object for execution.
 
   template<
       typename ``[link boost_asio.reference.Executor1 Executor]``,
-      typename CompletionToken>
+      typename CompletionToken = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.defer.overload2 defer]``(
       const Executor & ex,
-      CompletionToken && token,
+      CompletionToken && token = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_executor< Executor >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.defer.overload2 more...]]``
 
   template<
       typename ExecutionContext,
-      typename CompletionToken>
+      typename CompletionToken = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.defer.overload3 defer]``(
       ExecutionContext & ctx,
-      CompletionToken && token,
+      CompletionToken && token = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.defer.overload3 more...]]``
 
@@ -58566,10 +60014,10 @@ Submits a completion token or function object for execution.
 
   template<
       typename ``[link boost_asio.reference.Executor1 Executor]``,
-      typename CompletionToken>
+      typename CompletionToken = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` defer(
       const Executor & ex,
-      CompletionToken && token,
+      CompletionToken && token = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_executor< Executor >::value >::type *  = 0);
 
 
@@ -58618,10 +60066,10 @@ Submits a completion token or function object for execution.
 
   template<
       typename ExecutionContext,
-      typename CompletionToken>
+      typename CompletionToken = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` defer(
       ExecutionContext & ctx,
-      CompletionToken && token,
+      CompletionToken && token = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type *  = 0);
 
 
@@ -58725,19 +60173,19 @@ Submits a completion token or function object for execution.
 
   template<
       typename ``[link boost_asio.reference.Executor1 Executor]``,
-      typename CompletionToken>
+      typename CompletionToken = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.dispatch.overload2 dispatch]``(
       const Executor & ex,
-      CompletionToken && token,
+      CompletionToken && token = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_executor< Executor >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.dispatch.overload2 more...]]``
 
   template<
       typename ExecutionContext,
-      typename CompletionToken>
+      typename CompletionToken = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.dispatch.overload3 dispatch]``(
       ExecutionContext & ctx,
-      CompletionToken && token,
+      CompletionToken && token = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.dispatch.overload3 more...]]``
 
@@ -58797,10 +60245,10 @@ Submits a completion token or function object for execution.
 
   template<
       typename ``[link boost_asio.reference.Executor1 Executor]``,
-      typename CompletionToken>
+      typename CompletionToken = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` dispatch(
       const Executor & ex,
-      CompletionToken && token,
+      CompletionToken && token = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_executor< Executor >::value >::type *  = 0);
 
 
@@ -58847,10 +60295,10 @@ Submits a completion token or function object for execution.
 
   template<
       typename ExecutionContext,
-      typename CompletionToken>
+      typename CompletionToken = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` dispatch(
       ExecutionContext & ctx,
-      CompletionToken && token,
+      CompletionToken && token = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type *  = 0);
 
 
@@ -67792,6 +69240,13 @@ Typedef for a timer based on the high resolution clock.
 
   [
 
+    [[link boost_asio.reference.basic_waitable_timer__rebind_executor [*rebind_executor]]]
+    [Rebinds the timer type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.basic_waitable_timer.clock_type [*clock_type]]]
     [The clock type. ]
   
@@ -77684,6 +79139,13 @@ Provides endpoint resolution functionality.
 
   [
 
+    [[link boost_asio.reference.ip__basic_resolver__rebind_executor [*rebind_executor]]]
+    [Rebinds the resolver type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.ip__basic_resolver.endpoint_type [*endpoint_type]]]
     [The endpoint type. ]
   
@@ -77885,10 +79347,10 @@ If used with v4\_mapped, return all matching IPv6 and IPv4 addresses.
 
 
   template<
-      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
+      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.ip__basic_resolver.async_resolve.overload1 async_resolve]``(
       const query & q,
-      ResolveHandler && handler);
+      ResolveHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.ip__basic_resolver.async_resolve.overload1 more...]]``
 
 
@@ -77896,39 +79358,39 @@ Asynchronously perform forward resolution of a query to a list of entries.
 
 
   template<
-      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
+      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.ip__basic_resolver.async_resolve.overload2 async_resolve]``(
       string_view host,
       string_view service,
-      ResolveHandler && handler);
+      ResolveHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.ip__basic_resolver.async_resolve.overload2 more...]]``
 
   template<
-      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
+      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.ip__basic_resolver.async_resolve.overload3 async_resolve]``(
       string_view host,
       string_view service,
       resolver_base::flags resolve_flags,
-      ResolveHandler && handler);
+      ResolveHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.ip__basic_resolver.async_resolve.overload3 more...]]``
 
   template<
-      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
+      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.ip__basic_resolver.async_resolve.overload4 async_resolve]``(
       const protocol_type & protocol,
       string_view host,
       string_view service,
-      ResolveHandler && handler);
+      ResolveHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.ip__basic_resolver.async_resolve.overload4 more...]]``
 
   template<
-      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
+      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.ip__basic_resolver.async_resolve.overload5 async_resolve]``(
       const protocol_type & protocol,
       string_view host,
       string_view service,
       resolver_base::flags resolve_flags,
-      ResolveHandler && handler);
+      ResolveHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.ip__basic_resolver.async_resolve.overload5 more...]]``
 
 
@@ -77936,10 +79398,10 @@ Asynchronously perform reverse resolution of an endpoint to a list of entries.
 
 
   template<
-      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
+      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.ip__basic_resolver.async_resolve.overload6 async_resolve]``(
       const endpoint_type & e,
-      ResolveHandler && handler);
+      ResolveHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.ip__basic_resolver.async_resolve.overload6 more...]]``
 
 
@@ -77950,10 +79412,10 @@ Asynchronously perform reverse resolution of an endpoint to a list of entries.
 
 
   template<
-      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
+      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_resolve(
       const query & q,
-      ResolveHandler && handler);
+      ResolveHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously resolve a query into a list of endpoint entries.
@@ -77991,11 +79453,11 @@ Asynchronously perform forward resolution of a query to a list of entries.
 
 
   template<
-      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
+      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_resolve(
       string_view host,
       string_view service,
-      ResolveHandler && handler);
+      ResolveHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to resolve host and service names into a list of endpoint entries.
@@ -78042,12 +79504,12 @@ Asynchronously perform forward resolution of a query to a list of entries.
 
 
   template<
-      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
+      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_resolve(
       string_view host,
       string_view service,
       resolver_base::flags resolve_flags,
-      ResolveHandler && handler);
+      ResolveHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to resolve host and service names into a list of endpoint entries.
@@ -78096,12 +79558,12 @@ Asynchronously perform forward resolution of a query to a list of entries.
 
 
   template<
-      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
+      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_resolve(
       const protocol_type & protocol,
       string_view host,
       string_view service,
-      ResolveHandler && handler);
+      ResolveHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to resolve host and service names into a list of endpoint entries.
@@ -78150,13 +79612,13 @@ Asynchronously perform forward resolution of a query to a list of entries.
 
 
   template<
-      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
+      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_resolve(
       const protocol_type & protocol,
       string_view host,
       string_view service,
       resolver_base::flags resolve_flags,
-      ResolveHandler && handler);
+      ResolveHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to resolve host and service names into a list of endpoint entries.
@@ -78207,10 +79669,10 @@ Asynchronously perform reverse resolution of an endpoint to a list of entries.
 
 
   template<
-      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
+      typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_resolve(
       const endpoint_type & e,
-      ResolveHandler && handler);
+      ResolveHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously resolve an endpoint into a list of endpoint entries.
@@ -79839,6 +81301,227 @@ This function destroys the resolver, cancelling any outstanding asynchronous wai
 
 [endsect]
 
+[section:ip__basic_resolver__rebind_executor ip::basic_resolver::rebind_executor]
+
+
+Rebinds the resolver type to another executor. 
+
+
+  template<
+      typename ``[link boost_asio.reference.Executor1 Executor1]``>
+  struct rebind_executor
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.ip__basic_resolver__rebind_executor.other [*other]]]
+    [The resolver type when rebound to the specified executor. ]
+  
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^boost/asio/ip/basic_resolver.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[section:other ip::basic_resolver::rebind_executor::other]
+
+[indexterm2 boost_asio.indexterm.ip__basic_resolver__rebind_executor.other..other..ip::basic_resolver::rebind_executor] 
+The resolver type when rebound to the specified executor. 
+
+
+  typedef basic_resolver< InternetProtocol, Executor1 > other;
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.ip__basic_resolver__rebind_executor [*rebind_executor]]]
+    [Rebinds the resolver type to another executor. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.ip__basic_resolver.endpoint_type [*endpoint_type]]]
+    [The endpoint type. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.ip__basic_resolver.executor_type [*executor_type]]]
+    [The type of the executor associated with the object. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.ip__basic_resolver.flags [*flags]]]
+    [A bitmask type (C++ Std \[lib.bitmask.types\]). ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.ip__basic_resolver.iterator [*iterator]]]
+    [(Deprecated.) The iterator type. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.ip__basic_resolver.protocol_type [*protocol_type]]]
+    [The protocol type. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.ip__basic_resolver.query [*query]]]
+    [(Deprecated.) The query type. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.ip__basic_resolver.results_type [*results_type]]]
+    [The results type. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.ip__basic_resolver.async_resolve [*async_resolve]]]
+    [(Deprecated: Use overload with separate host and service parameters.) Asynchronously perform forward resolution of a query to a list of entries. 
+     [hr]
+     Asynchronously perform forward resolution of a query to a list of entries. 
+     [hr]
+     Asynchronously perform reverse resolution of an endpoint to a list of entries. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.ip__basic_resolver.basic_resolver [*basic_resolver]]]
+    [Construct with executor. 
+     [hr]
+     Construct with execution context. 
+     [hr]
+     Move-construct a basic_resolver from another. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.ip__basic_resolver.cancel [*cancel]]]
+    [Cancel any asynchronous operations that are waiting on the resolver. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.ip__basic_resolver.get_executor [*get_executor]]]
+    [Get the executor associated with the object. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.ip__basic_resolver.operator_eq_ [*operator=]]]
+    [Move-assign a basic_resolver from another. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.ip__basic_resolver.resolve [*resolve]]]
+    [(Deprecated: Use overload with separate host and service parameters.) Perform forward resolution of a query to a list of entries. 
+     [hr]
+     Perform forward resolution of a query to a list of entries. 
+     [hr]
+     Perform reverse resolution of an endpoint to a list of entries. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.ip__basic_resolver._basic_resolver [*~basic_resolver]]]
+    [Destroys the resolver. ]
+  ]
+  
+]
+
+[heading Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.ip__basic_resolver.address_configured [*address_configured]]]
+    [Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. ]
+  ]
+
+  [
+    [[link boost_asio.reference.ip__basic_resolver.all_matching [*all_matching]]]
+    [If used with v4_mapped, return all matching IPv6 and IPv4 addresses. ]
+  ]
+
+  [
+    [[link boost_asio.reference.ip__basic_resolver.canonical_name [*canonical_name]]]
+    [Determine the canonical name of the host specified in the query. ]
+  ]
+
+  [
+    [[link boost_asio.reference.ip__basic_resolver.numeric_host [*numeric_host]]]
+    [Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. ]
+  ]
+
+  [
+    [[link boost_asio.reference.ip__basic_resolver.numeric_service [*numeric_service]]]
+    [Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. ]
+  ]
+
+  [
+    [[link boost_asio.reference.ip__basic_resolver.passive [*passive]]]
+    [Indicate that returned endpoint is intended for use as a locally bound socket endpoint. ]
+  ]
+
+  [
+    [[link boost_asio.reference.ip__basic_resolver.v4_mapped [*v4_mapped]]]
+    [If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. ]
+  ]
+
+]
+
+The [link boost_asio.reference.ip__basic_resolver `ip::basic_resolver`] class template provides the ability to resolve a query to a list of endpoints.
+
+
+[heading Thread Safety]
+  
+['Distinct] ['objects:] Safe.
+
+['Shared] ['objects:] Unsafe. 
+
+
+
+
+[heading Requirements]
+
+['Header: ][^boost/asio/ip/basic_resolver.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
 [section:ip__basic_resolver_entry ip::basic_resolver_entry]
 
 
@@ -83303,6 +84986,13 @@ The ICMP resolver type.
 
   [
 
+    [[link boost_asio.reference.ip__basic_resolver__rebind_executor [*rebind_executor]]]
+    [Rebinds the resolver type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.ip__basic_resolver.endpoint_type [*endpoint_type]]]
     [The endpoint type. ]
   
@@ -85874,6 +87564,13 @@ The TCP acceptor type.
 
   [
 
+    [[link boost_asio.reference.basic_socket_acceptor__rebind_executor [*rebind_executor]]]
+    [Rebinds the acceptor type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.basic_socket_acceptor.broadcast [*broadcast]]]
     [Socket option to permit sending of broadcast messages. ]
   
@@ -86677,6 +88374,13 @@ The TCP resolver type.
 
   [
 
+    [[link boost_asio.reference.ip__basic_resolver__rebind_executor [*rebind_executor]]]
+    [Rebinds the resolver type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.ip__basic_resolver.endpoint_type [*endpoint_type]]]
     [The endpoint type. ]
   
@@ -87682,6 +89386,13 @@ The UDP resolver type.
 
   [
 
+    [[link boost_asio.reference.ip__basic_resolver__rebind_executor [*rebind_executor]]]
+    [Rebinds the resolver type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.ip__basic_resolver.endpoint_type [*endpoint_type]]]
     [The endpoint type. ]
   
@@ -90275,6 +91986,13 @@ The UNIX domain acceptor type.
 
   [
 
+    [[link boost_asio.reference.basic_socket_acceptor__rebind_executor [*rebind_executor]]]
+    [Rebinds the acceptor type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.basic_socket_acceptor.broadcast [*broadcast]]]
     [Socket option to permit sending of broadcast messages. ]
   
@@ -92544,6 +94262,13 @@ Provides POSIX descriptor functionality.
 
   [
 
+    [[link boost_asio.reference.posix__basic_descriptor__rebind_executor [*rebind_executor]]]
+    [Rebinds the descriptor type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.posix__basic_descriptor.bytes_readable [*bytes_readable]]]
     [IO control command to get the amount of data that can be read without blocking. ]
   
@@ -92765,10 +94490,10 @@ Asynchronously wait for the descriptor to become ready to read, ready to write,
 
 
   template<
-      typename ``[link boost_asio.reference.WaitHandler WaitHandler]``>
+      typename ``[link boost_asio.reference.WaitHandler WaitHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
       wait_type w,
-      WaitHandler && handler);
+      WaitHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to perform an asynchronous wait for a descriptor to enter a ready to read, write or error condition state.
@@ -93506,6 +95231,13 @@ A descriptor is always the lowest layer.
 
   [
 
+    [[link boost_asio.reference.posix__basic_descriptor__rebind_executor [*rebind_executor]]]
+    [Rebinds the descriptor type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.posix__basic_descriptor.bytes_readable [*bytes_readable]]]
     [IO control command to get the amount of data that can be read without blocking. ]
   
@@ -94180,6 +95912,232 @@ This function destroys the descriptor, cancelling any outstanding asynchronous w
 
 [endsect]
 
+[section:posix__basic_descriptor__rebind_executor posix::basic_descriptor::rebind_executor]
+
+
+Rebinds the descriptor type to another executor. 
+
+
+  template<
+      typename ``[link boost_asio.reference.Executor1 Executor1]``>
+  struct rebind_executor
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.posix__basic_descriptor__rebind_executor.other [*other]]]
+    [The descriptor type when rebound to the specified executor. ]
+  
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^boost/asio/posix/basic_descriptor.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[section:other posix::basic_descriptor::rebind_executor::other]
+
+[indexterm2 boost_asio.indexterm.posix__basic_descriptor__rebind_executor.other..other..posix::basic_descriptor::rebind_executor] 
+The descriptor type when rebound to the specified executor. 
+
+
+  typedef basic_descriptor< Executor1 > other;
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.posix__basic_descriptor__rebind_executor [*rebind_executor]]]
+    [Rebinds the descriptor type to another executor. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.posix__basic_descriptor.bytes_readable [*bytes_readable]]]
+    [IO control command to get the amount of data that can be read without blocking. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.posix__basic_descriptor.executor_type [*executor_type]]]
+    [The type of the executor associated with the object. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.posix__basic_descriptor.lowest_layer_type [*lowest_layer_type]]]
+    [A descriptor is always the lowest layer. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.posix__basic_descriptor.native_handle_type [*native_handle_type]]]
+    [The native representation of a descriptor. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.posix__basic_descriptor.wait_type [*wait_type]]]
+    [Wait types. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.posix__basic_descriptor.assign [*assign]]]
+    [Assign an existing native descriptor to the descriptor. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_descriptor.async_wait [*async_wait]]]
+    [Asynchronously wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_descriptor.basic_descriptor [*basic_descriptor]]]
+    [Construct a descriptor without opening it. 
+     [hr]
+     Construct a descriptor on an existing native descriptor. 
+     [hr]
+     Move-construct a descriptor from another. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_descriptor.cancel [*cancel]]]
+    [Cancel all asynchronous operations associated with the descriptor. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_descriptor.close [*close]]]
+    [Close the descriptor. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_descriptor.get_executor [*get_executor]]]
+    [Get the executor associated with the object. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_descriptor.io_control [*io_control]]]
+    [Perform an IO control command on the descriptor. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_descriptor.is_open [*is_open]]]
+    [Determine whether the descriptor is open. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_descriptor.lowest_layer [*lowest_layer]]]
+    [Get a reference to the lowest layer. 
+     [hr]
+     Get a const reference to the lowest layer. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_descriptor.native_handle [*native_handle]]]
+    [Get the native descriptor representation. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_descriptor.native_non_blocking [*native_non_blocking]]]
+    [Gets the non-blocking mode of the native descriptor implementation. 
+     [hr]
+     Sets the non-blocking mode of the native descriptor implementation. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_descriptor.non_blocking [*non_blocking]]]
+    [Gets the non-blocking mode of the descriptor. 
+     [hr]
+     Sets the non-blocking mode of the descriptor. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_descriptor.operator_eq_ [*operator=]]]
+    [Move-assign a descriptor from another. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_descriptor.release [*release]]]
+    [Release ownership of the native descriptor implementation. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_descriptor.wait [*wait]]]
+    [Wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
+  ]
+  
+]
+
+[heading Protected Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.posix__basic_descriptor._basic_descriptor [*~basic_descriptor]]]
+    [Protected destructor to prevent deletion through this type. ]
+  ]
+  
+]
+
+[heading Protected Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.posix__basic_descriptor.impl_ [*impl_]]]
+    []
+  ]
+
+]
+
+The [link boost_asio.reference.posix__basic_descriptor `posix::basic_descriptor`] class template provides the ability to wrap a POSIX descriptor.
+
+
+[heading Thread Safety]
+  
+['Distinct] ['objects:] Safe.
+
+['Shared] ['objects:] Unsafe. 
+
+
+
+
+[heading Requirements]
+
+['Header: ][^boost/asio/posix/basic_descriptor.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
 [section:posix__basic_stream_descriptor posix::basic_stream_descriptor]
 
 
@@ -94198,6 +96156,13 @@ Provides stream-oriented descriptor functionality.
 
   [
 
+    [[link boost_asio.reference.posix__basic_stream_descriptor__rebind_executor [*rebind_executor]]]
+    [Rebinds the descriptor type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.posix__basic_stream_descriptor.bytes_readable [*bytes_readable]]]
     [IO control command to get the amount of data that can be read without blocking. ]
   
@@ -94436,10 +96401,10 @@ Start an asynchronous read.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some(
       const MutableBufferSequence & buffers,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously read data from the stream descriptor. The function call always returns immediately.
@@ -94495,10 +96460,10 @@ Asynchronously wait for the descriptor to become ready to read, ready to write,
 
 
   template<
-      typename ``[link boost_asio.reference.WaitHandler WaitHandler]``>
+      typename ``[link boost_asio.reference.WaitHandler WaitHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
       wait_type w,
-      WaitHandler && handler);
+      WaitHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to perform an asynchronous wait for a descriptor to enter a ready to read, write or error condition state.
@@ -94560,10 +96525,10 @@ Start an asynchronous write.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some(
       const ConstBufferSequence & buffers,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously write data to the stream descriptor. The function call always returns immediately.
@@ -95329,6 +97294,13 @@ A descriptor is always the lowest layer.
 
   [
 
+    [[link boost_asio.reference.posix__basic_descriptor__rebind_executor [*rebind_executor]]]
+    [Rebinds the descriptor type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.posix__basic_descriptor.bytes_readable [*bytes_readable]]]
     [IO control command to get the amount of data that can be read without blocking. ]
   
@@ -95534,6 +97506,13 @@ The native representation of a descriptor.
 
   [
 
+    [[link boost_asio.reference.posix__basic_descriptor__rebind_executor [*rebind_executor]]]
+    [Rebinds the descriptor type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.posix__basic_descriptor.bytes_readable [*bytes_readable]]]
     [IO control command to get the amount of data that can be read without blocking. ]
   
@@ -96434,6 +98413,242 @@ The write\_some operation may not transmit all of the data to the peer. Consider
 
 [endsect]
 
+[section:posix__basic_stream_descriptor__rebind_executor posix::basic_stream_descriptor::rebind_executor]
+
+
+Rebinds the descriptor type to another executor. 
+
+
+  template<
+      typename ``[link boost_asio.reference.Executor1 Executor1]``>
+  struct rebind_executor
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.posix__basic_stream_descriptor__rebind_executor.other [*other]]]
+    [The descriptor type when rebound to the specified executor. ]
+  
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^boost/asio/posix/basic_stream_descriptor.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[section:other posix::basic_stream_descriptor::rebind_executor::other]
+
+[indexterm2 boost_asio.indexterm.posix__basic_stream_descriptor__rebind_executor.other..other..posix::basic_stream_descriptor::rebind_executor] 
+The descriptor type when rebound to the specified executor. 
+
+
+  typedef basic_stream_descriptor< Executor1 > other;
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.posix__basic_stream_descriptor__rebind_executor [*rebind_executor]]]
+    [Rebinds the descriptor type to another executor. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.posix__basic_stream_descriptor.bytes_readable [*bytes_readable]]]
+    [IO control command to get the amount of data that can be read without blocking. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.posix__basic_stream_descriptor.executor_type [*executor_type]]]
+    [The type of the executor associated with the object. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.posix__basic_stream_descriptor.lowest_layer_type [*lowest_layer_type]]]
+    [A descriptor is always the lowest layer. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.posix__basic_stream_descriptor.native_handle_type [*native_handle_type]]]
+    [The native representation of a descriptor. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.posix__basic_stream_descriptor.wait_type [*wait_type]]]
+    [Wait types. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.posix__basic_stream_descriptor.assign [*assign]]]
+    [Assign an existing native descriptor to the descriptor. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_stream_descriptor.async_read_some [*async_read_some]]]
+    [Start an asynchronous read. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_stream_descriptor.async_wait [*async_wait]]]
+    [Asynchronously wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_stream_descriptor.async_write_some [*async_write_some]]]
+    [Start an asynchronous write. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor [*basic_stream_descriptor]]]
+    [Construct a stream descriptor without opening it. 
+     [hr]
+     Construct a stream descriptor on an existing native descriptor. 
+     [hr]
+     Move-construct a stream descriptor from another. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_stream_descriptor.cancel [*cancel]]]
+    [Cancel all asynchronous operations associated with the descriptor. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_stream_descriptor.close [*close]]]
+    [Close the descriptor. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_stream_descriptor.get_executor [*get_executor]]]
+    [Get the executor associated with the object. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_stream_descriptor.io_control [*io_control]]]
+    [Perform an IO control command on the descriptor. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_stream_descriptor.is_open [*is_open]]]
+    [Determine whether the descriptor is open. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_stream_descriptor.lowest_layer [*lowest_layer]]]
+    [Get a reference to the lowest layer. 
+     [hr]
+     Get a const reference to the lowest layer. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_stream_descriptor.native_handle [*native_handle]]]
+    [Get the native descriptor representation. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_stream_descriptor.native_non_blocking [*native_non_blocking]]]
+    [Gets the non-blocking mode of the native descriptor implementation. 
+     [hr]
+     Sets the non-blocking mode of the native descriptor implementation. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_stream_descriptor.non_blocking [*non_blocking]]]
+    [Gets the non-blocking mode of the descriptor. 
+     [hr]
+     Sets the non-blocking mode of the descriptor. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_stream_descriptor.operator_eq_ [*operator=]]]
+    [Move-assign a stream descriptor from another. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_stream_descriptor.read_some [*read_some]]]
+    [Read some data from the descriptor. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_stream_descriptor.release [*release]]]
+    [Release ownership of the native descriptor implementation. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_stream_descriptor.wait [*wait]]]
+    [Wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.posix__basic_stream_descriptor.write_some [*write_some]]]
+    [Write some data to the descriptor. ]
+  ]
+  
+]
+
+[heading Protected Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.posix__basic_stream_descriptor.impl_ [*impl_]]]
+    []
+  ]
+
+]
+
+The [link boost_asio.reference.posix__basic_stream_descriptor `posix::basic_stream_descriptor`] class template provides asynchronous and blocking stream-oriented descriptor functionality.
+
+
+[heading Thread Safety]
+  
+['Distinct] ['objects:] Safe.
+
+['Shared] ['objects:] Unsafe.
+
+
+
+
+
+[heading Requirements]
+
+['Header: ][^boost/asio/posix/basic_stream_descriptor.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
 
 [section:posix__descriptor posix::descriptor]
 
@@ -96450,6 +98665,13 @@ Typedef for the typical usage of [link boost_asio.reference.posix__basic_descrip
 
   [
 
+    [[link boost_asio.reference.posix__basic_descriptor__rebind_executor [*rebind_executor]]]
+    [Rebinds the descriptor type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.posix__basic_descriptor.bytes_readable [*bytes_readable]]]
     [IO control command to get the amount of data that can be read without blocking. ]
   
@@ -96779,6 +99001,13 @@ Typedef for the typical usage of a stream-oriented descriptor.
 
   [
 
+    [[link boost_asio.reference.posix__basic_stream_descriptor__rebind_executor [*rebind_executor]]]
+    [Rebinds the descriptor type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.posix__basic_stream_descriptor.bytes_readable [*bytes_readable]]]
     [IO control command to get the amount of data that can be read without blocking. ]
   
@@ -96972,19 +99201,19 @@ Submits a completion token or function object for execution.
 
   template<
       typename ``[link boost_asio.reference.Executor1 Executor]``,
-      typename CompletionToken>
+      typename CompletionToken = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.post.overload2 post]``(
       const Executor & ex,
-      CompletionToken && token,
+      CompletionToken && token = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_executor< Executor >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.post.overload2 more...]]``
 
   template<
       typename ExecutionContext,
-      typename CompletionToken>
+      typename CompletionToken = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.post.overload3 post]``(
       ExecutionContext & ctx,
-      CompletionToken && token,
+      CompletionToken && token = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type *  = 0);
   ``  [''''&raquo;''' [link boost_asio.reference.post.overload3 more...]]``
 
@@ -97046,10 +99275,10 @@ Submits a completion token or function object for execution.
 
   template<
       typename ``[link boost_asio.reference.Executor1 Executor]``,
-      typename CompletionToken>
+      typename CompletionToken = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` post(
       const Executor & ex,
-      CompletionToken && token,
+      CompletionToken && token = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_executor< Executor >::value >::type *  = 0);
 
 
@@ -97098,10 +99327,10 @@ Submits a completion token or function object for execution.
 
   template<
       typename ExecutionContext,
-      typename CompletionToken>
+      typename CompletionToken = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` post(
       ExecutionContext & ctx,
-      CompletionToken && token,
+      CompletionToken && token = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
       typename enable_if< is_convertible< ExecutionContext &, execution_context & >::value >::type *  = 0);
 
 
@@ -101528,6 +103757,13 @@ Typedef for the typical usage of a serial port.
 
   [
 
+    [[link boost_asio.reference.basic_serial_port__rebind_executor [*rebind_executor]]]
+    [Rebinds the serial port type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.basic_serial_port.executor_type [*executor_type]]]
     [The type of the executor associated with the object. ]
   
@@ -102458,6 +104694,13 @@ Typedef for the typical usage of a signal set.
 
   [
 
+    [[link boost_asio.reference.basic_signal_set__rebind_executor [*rebind_executor]]]
+    [Rebinds the signal set type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.basic_signal_set.executor_type [*executor_type]]]
     [The type of the executor associated with the object. ]
   
@@ -107772,19 +110015,19 @@ Start an asynchronous SSL handshake.
 
 
   template<
-      typename ``[link boost_asio.reference.HandshakeHandler HandshakeHandler]``>
+      typename ``[link boost_asio.reference.HandshakeHandler HandshakeHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.ssl__stream.async_handshake.overload1 async_handshake]``(
       handshake_type type,
-      HandshakeHandler && handler);
+      HandshakeHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.ssl__stream.async_handshake.overload1 more...]]``
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.BufferedHandshakeHandler BufferedHandshakeHandler]``>
+      typename ``[link boost_asio.reference.BufferedHandshakeHandler BufferedHandshakeHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link boost_asio.reference.ssl__stream.async_handshake.overload2 async_handshake]``(
       handshake_type type,
       const ConstBufferSequence & buffers,
-      BufferedHandshakeHandler && handler);
+      BufferedHandshakeHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
   ``  [''''&raquo;''' [link boost_asio.reference.ssl__stream.async_handshake.overload2 more...]]``
 
 
@@ -107795,10 +110038,10 @@ Start an asynchronous SSL handshake.
 
 
   template<
-      typename ``[link boost_asio.reference.HandshakeHandler HandshakeHandler]``>
+      typename ``[link boost_asio.reference.HandshakeHandler HandshakeHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_handshake(
       handshake_type type,
-      HandshakeHandler && handler);
+      HandshakeHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously perform an SSL handshake on the stream. This function call always returns immediately.
@@ -107836,11 +110079,11 @@ Start an asynchronous SSL handshake.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.BufferedHandshakeHandler BufferedHandshakeHandler]``>
+      typename ``[link boost_asio.reference.BufferedHandshakeHandler BufferedHandshakeHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_handshake(
       handshake_type type,
       const ConstBufferSequence & buffers,
-      BufferedHandshakeHandler && handler);
+      BufferedHandshakeHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously perform an SSL handshake on the stream. This function call always returns immediately.
@@ -107883,10 +110126,10 @@ Start an asynchronous read.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some(
       const MutableBufferSequence & buffers,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously read one or more bytes of data from the stream. The function call always returns immediately.
@@ -107929,9 +110172,9 @@ Asynchronously shut down SSL on the stream.
 
 
   template<
-      typename ``[link boost_asio.reference.ShutdownHandler ShutdownHandler]``>
+      typename ``[link boost_asio.reference.ShutdownHandler ShutdownHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_shutdown(
-      ShutdownHandler && handler);
+      ShutdownHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously shut down SSL on the stream. This function call always returns immediately.
@@ -107967,10 +110210,10 @@ Start an asynchronous write.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some(
       const ConstBufferSequence & buffers,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously write one or more bytes of data to the stream. The function call always returns immediately.
@@ -109530,6 +111773,13 @@ Typedef for a timer based on the steady clock.
 
   [
 
+    [[link boost_asio.reference.basic_waitable_timer__rebind_executor [*rebind_executor]]]
+    [Rebinds the timer type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.basic_waitable_timer.clock_type [*clock_type]]]
     [The clock type. ]
   
@@ -111591,6 +113841,13 @@ Typedef for a timer based on the system clock.
 
   [
 
+    [[link boost_asio.reference.basic_waitable_timer__rebind_executor [*rebind_executor]]]
+    [Rebinds the timer type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.basic_waitable_timer.clock_type [*clock_type]]]
     [The clock type. ]
   
@@ -113256,13 +115513,31 @@ A completion token that represents the currently executing coroutine.
   struct use_awaitable_t
 
 
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.use_awaitable_t__executor_with_default [*executor_with_default]]]
+    [Adapts an executor to add the use_awaitable_t completion token as the default. ]
+  
+  ]
+
+]
+
 [heading Member Functions]
 [table
   [[Name][Description]]
 
   [
+    [[link boost_asio.reference.use_awaitable_t.as_default_on [*as_default_on]]]
+    [Function helper to adapt an I/O object to use use_awaitable_t as its default completion token type. ]
+  ]
+  
+  [
     [[link boost_asio.reference.use_awaitable_t.use_awaitable_t [*use_awaitable_t]]]
-    []
+    [Default constructor. ]
   ]
   
 ]
@@ -113289,9 +115564,28 @@ When used with co\_await, the initiating function (`async_read_some` in the abov
 ['Convenience header: ][^boost/asio.hpp]
 
 
+[section:as_default_on use_awaitable_t::as_default_on]
+
+[indexterm2 boost_asio.indexterm.use_awaitable_t.as_default_on..as_default_on..use_awaitable_t] 
+Function helper to adapt an I/O object to use `use_awaitable_t` as its default completion token type. 
+
+
+  template<
+      typename T>
+  static T::template rebind_executor< executor_with_default< typename T::executor_type > >::other as_default_on(
+      T && object);
+
+
+
+[endsect]
+
+
+
 [section:use_awaitable_t use_awaitable_t::use_awaitable_t]
 
 [indexterm2 boost_asio.indexterm.use_awaitable_t.use_awaitable_t..use_awaitable_t..use_awaitable_t] 
+Default constructor. 
+
 
   constexpr use_awaitable_t();
 
@@ -113303,6 +115597,130 @@ When used with co\_await, the initiating function (`async_read_some` in the abov
 
 [endsect]
 
+[section:use_awaitable_t__executor_with_default use_awaitable_t::executor_with_default]
+
+
+Adapts an executor to add the `use_awaitable_t` completion token as the default. 
+
+
+  template<
+      typename ``[link boost_asio.reference.Executor1 InnerExecutor]``>
+  struct executor_with_default
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.use_awaitable_t__executor_with_default.default_completion_token_type [*default_completion_token_type]]]
+    [Specify use_awaitable_t as the default completion token type. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.use_awaitable_t__executor_with_default.executor_with_default [*executor_with_default]]]
+    [Construct the adapted executor from the inner executor type. ]
+  ]
+  
+]
+
+[heading Requirements]
+
+['Header: ][^boost/asio/use_awaitable.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[section:default_completion_token_type use_awaitable_t::executor_with_default::default_completion_token_type]
+
+[indexterm2 boost_asio.indexterm.use_awaitable_t__executor_with_default.default_completion_token_type..default_completion_token_type..use_awaitable_t::executor_with_default] 
+Specify `use_awaitable_t` as the default completion token type. 
+
+
+  typedef use_awaitable_t default_completion_token_type;
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.use_awaitable_t__executor_with_default [*executor_with_default]]]
+    [Adapts an executor to add the use_awaitable_t completion token as the default. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.use_awaitable_t.as_default_on [*as_default_on]]]
+    [Function helper to adapt an I/O object to use use_awaitable_t as its default completion token type. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.use_awaitable_t.use_awaitable_t [*use_awaitable_t]]]
+    [Default constructor. ]
+  ]
+  
+]
+
+The `use_awaitable_t` class, with its value `use_awaitable`, is used to represent the currently executing coroutine. This completion token may be passed as a handler to an asynchronous operation. For example:
+
+
+
+   awaitable<void> my_coroutine()
+   {
+     std::size_t n = co_await my_socket.async_read_some(buffer, use_awaitable);
+     ...
+   } 
+
+
+
+
+When used with co\_await, the initiating function (`async_read_some` in the above example) suspends the current coroutine. The coroutine is resumed when the asynchronous operation completes, and the result of the operation is returned. 
+
+
+[heading Requirements]
+
+['Header: ][^boost/asio/use_awaitable.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[endsect]
+
+
+
+[section:executor_with_default use_awaitable_t::executor_with_default::executor_with_default]
+
+[indexterm2 boost_asio.indexterm.use_awaitable_t__executor_with_default.executor_with_default..executor_with_default..use_awaitable_t::executor_with_default] 
+Construct the adapted executor from the inner executor type. 
+
+
+  executor_with_default(
+      const InnerExecutor & ex);
+
+
+
+[endsect]
+
+
+
+[endsect]
+
 
 [section:use_future use_future]
 
@@ -113689,6 +116107,13 @@ Provides object-oriented handle functionality.
 
   [
 
+    [[link boost_asio.reference.windows__basic_object_handle__rebind_executor [*rebind_executor]]]
+    [Rebinds the handle type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.windows__basic_object_handle.executor_type [*executor_type]]]
     [The type of the executor associated with the object. ]
   
@@ -113850,9 +116275,9 @@ Start an asynchronous wait on the object handle.
 
 
   template<
-      typename ``[link boost_asio.reference.WaitHandler WaitHandler]``>
+      typename ``[link boost_asio.reference.WaitHandler WaitHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
-      WaitHandler && handler);
+      WaitHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is be used to initiate an asynchronous wait against the object handle. It always returns immediately.
@@ -114378,6 +116803,322 @@ An object handle is always the lowest layer.
 
   [
 
+    [[link boost_asio.reference.windows__basic_object_handle__rebind_executor [*rebind_executor]]]
+    [Rebinds the handle type to another executor. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.windows__basic_object_handle.executor_type [*executor_type]]]
+    [The type of the executor associated with the object. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.windows__basic_object_handle.lowest_layer_type [*lowest_layer_type]]]
+    [An object handle is always the lowest layer. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.windows__basic_object_handle.native_handle_type [*native_handle_type]]]
+    [The native representation of a handle. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.windows__basic_object_handle.assign [*assign]]]
+    [Assign an existing native handle to the handle. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_object_handle.async_wait [*async_wait]]]
+    [Start an asynchronous wait on the object handle. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_object_handle.basic_object_handle [*basic_object_handle]]]
+    [Construct an object handle without opening it. 
+     [hr]
+     Construct an object handle on an existing native handle. 
+     [hr]
+     Move-construct an object handle from another. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_object_handle.cancel [*cancel]]]
+    [Cancel all asynchronous operations associated with the handle. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_object_handle.close [*close]]]
+    [Close the handle. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_object_handle.get_executor [*get_executor]]]
+    [Get the executor associated with the object. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_object_handle.is_open [*is_open]]]
+    [Determine whether the handle is open. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_object_handle.lowest_layer [*lowest_layer]]]
+    [Get a reference to the lowest layer. 
+     [hr]
+     Get a const reference to the lowest layer. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_object_handle.native_handle [*native_handle]]]
+    [Get the native handle representation. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_object_handle.operator_eq_ [*operator=]]]
+    [Move-assign an object handle from another. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_object_handle.wait [*wait]]]
+    [Perform a blocking wait on the object handle. ]
+  ]
+  
+]
+
+The [link boost_asio.reference.windows__basic_object_handle `windows::basic_object_handle`] class provides asynchronous and blocking object-oriented handle functionality.
+
+
+[heading Thread Safety]
+  
+['Distinct] ['objects:] Safe.
+
+['Shared] ['objects:] Unsafe. 
+
+
+
+
+[heading Requirements]
+
+['Header: ][^boost/asio/windows/basic_object_handle.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[endsect]
+
+
+
+[section:native_handle windows::basic_object_handle::native_handle]
+
+[indexterm2 boost_asio.indexterm.windows__basic_object_handle.native_handle..native_handle..windows::basic_object_handle] 
+Get the native handle representation. 
+
+
+  native_handle_type native_handle();
+
+
+This function may be used to obtain the underlying representation of the handle. This is intended to allow access to native handle functionality that is not otherwise provided. 
+
+
+[endsect]
+
+
+
+[section:native_handle_type windows::basic_object_handle::native_handle_type]
+
+[indexterm2 boost_asio.indexterm.windows__basic_object_handle.native_handle_type..native_handle_type..windows::basic_object_handle] 
+The native representation of a handle. 
+
+
+  typedef implementation_defined native_handle_type;
+
+
+
+[heading Requirements]
+
+['Header: ][^boost/asio/windows/basic_object_handle.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[endsect]
+
+
+
+[section:operator_eq_ windows::basic_object_handle::operator=]
+
+[indexterm2 boost_asio.indexterm.windows__basic_object_handle.operator_eq_..operator=..windows::basic_object_handle] 
+Move-assign an object handle from another. 
+
+
+  basic_object_handle & operator=(
+      basic_object_handle && other);
+
+
+This assignment operator moves an object handle from one object to another.
+
+
+[heading Parameters]
+    
+
+[variablelist
+  
+[[other][The other object handle object from which the move will occur.]]
+
+]
+
+
+[heading Remarks]
+      
+Following the move, the moved-from object is in the same state as if constructed using the `basic_object_handle(const executor_type&)` constructor. 
+
+
+
+
+[endsect]
+
+
+[section:wait windows::basic_object_handle::wait]
+
+[indexterm2 boost_asio.indexterm.windows__basic_object_handle.wait..wait..windows::basic_object_handle] 
+Perform a blocking wait on the object handle. 
+
+
+  void ``[link boost_asio.reference.windows__basic_object_handle.wait.overload1 wait]``();
+  ``  [''''&raquo;''' [link boost_asio.reference.windows__basic_object_handle.wait.overload1 more...]]``
+
+  void ``[link boost_asio.reference.windows__basic_object_handle.wait.overload2 wait]``(
+      boost::system::error_code & ec);
+  ``  [''''&raquo;''' [link boost_asio.reference.windows__basic_object_handle.wait.overload2 more...]]``
+
+
+[section:overload1 windows::basic_object_handle::wait (1 of 2 overloads)]
+
+
+Perform a blocking wait on the object handle. 
+
+
+  void wait();
+
+
+This function is used to wait for the object handle to be set to the signalled state. This function blocks and does not return until the object handle has been set to the signalled state.
+
+
+[heading Exceptions]
+    
+
+[variablelist
+  
+[[boost::system::system_error][Thrown on failure. ]]
+
+]
+
+
+
+
+[endsect]
+
+
+
+[section:overload2 windows::basic_object_handle::wait (2 of 2 overloads)]
+
+
+Perform a blocking wait on the object handle. 
+
+
+  void wait(
+      boost::system::error_code & ec);
+
+
+This function is used to wait for the object handle to be set to the signalled state. This function blocks and does not return until the object handle has been set to the signalled state.
+
+
+[heading Parameters]
+    
+
+[variablelist
+  
+[[ec][Set to indicate what error occurred, if any. ]]
+
+]
+
+
+
+
+[endsect]
+
+
+[endsect]
+
+
+[endsect]
+
+[section:windows__basic_object_handle__rebind_executor windows::basic_object_handle::rebind_executor]
+
+
+Rebinds the handle type to another executor. 
+
+
+  template<
+      typename ``[link boost_asio.reference.Executor1 Executor1]``>
+  struct rebind_executor
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.windows__basic_object_handle__rebind_executor.other [*other]]]
+    [The handle type when rebound to the specified executor. ]
+  
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^boost/asio/windows/basic_object_handle.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[section:other windows::basic_object_handle::rebind_executor::other]
+
+[indexterm2 boost_asio.indexterm.windows__basic_object_handle__rebind_executor.other..other..windows::basic_object_handle::rebind_executor] 
+The handle type when rebound to the specified executor. 
+
+
+  typedef basic_object_handle< Executor1 > other;
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.windows__basic_object_handle__rebind_executor [*rebind_executor]]]
+    [Rebinds the handle type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.windows__basic_object_handle.executor_type [*executor_type]]]
     [The type of the executor associated with the object. ]
   
@@ -114489,149 +117230,6 @@ The [link boost_asio.reference.windows__basic_object_handle `windows::basic_obje
 
 
 
-[section:native_handle windows::basic_object_handle::native_handle]
-
-[indexterm2 boost_asio.indexterm.windows__basic_object_handle.native_handle..native_handle..windows::basic_object_handle] 
-Get the native handle representation. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying representation of the handle. This is intended to allow access to native handle functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type windows::basic_object_handle::native_handle_type]
-
-[indexterm2 boost_asio.indexterm.windows__basic_object_handle.native_handle_type..native_handle_type..windows::basic_object_handle] 
-The native representation of a handle. 
-
-
-  typedef implementation_defined native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^boost/asio/windows/basic_object_handle.hpp]
-
-['Convenience header: ][^boost/asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq_ windows::basic_object_handle::operator=]
-
-[indexterm2 boost_asio.indexterm.windows__basic_object_handle.operator_eq_..operator=..windows::basic_object_handle] 
-Move-assign an object handle from another. 
-
-
-  basic_object_handle & operator=(
-      basic_object_handle && other);
-
-
-This assignment operator moves an object handle from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other object handle object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_object_handle(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[section:wait windows::basic_object_handle::wait]
-
-[indexterm2 boost_asio.indexterm.windows__basic_object_handle.wait..wait..windows::basic_object_handle] 
-Perform a blocking wait on the object handle. 
-
-
-  void ``[link boost_asio.reference.windows__basic_object_handle.wait.overload1 wait]``();
-  ``  [''''&raquo;''' [link boost_asio.reference.windows__basic_object_handle.wait.overload1 more...]]``
-
-  void ``[link boost_asio.reference.windows__basic_object_handle.wait.overload2 wait]``(
-      boost::system::error_code & ec);
-  ``  [''''&raquo;''' [link boost_asio.reference.windows__basic_object_handle.wait.overload2 more...]]``
-
-
-[section:overload1 windows::basic_object_handle::wait (1 of 2 overloads)]
-
-
-Perform a blocking wait on the object handle. 
-
-
-  void wait();
-
-
-This function is used to wait for the object handle to be set to the signalled state. This function blocks and does not return until the object handle has been set to the signalled state.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[boost::system::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_object_handle::wait (2 of 2 overloads)]
-
-
-Perform a blocking wait on the object handle. 
-
-
-  void wait(
-      boost::system::error_code & ec);
-
-
-This function is used to wait for the object handle to be set to the signalled state. This function blocks and does not return until the object handle has been set to the signalled state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
 [endsect]
 
 [section:windows__basic_overlapped_handle windows::basic_overlapped_handle]
@@ -114651,6 +117249,13 @@ Provides Windows handle functionality for objects that support overlapped I/O.
 
   [
 
+    [[link boost_asio.reference.windows__basic_overlapped_handle__rebind_executor [*rebind_executor]]]
+    [Rebinds the handle type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.windows__basic_overlapped_handle.executor_type [*executor_type]]]
     [The type of the executor associated with the object. ]
   
@@ -115327,6 +117932,13 @@ An overlapped\_handle is always the lowest layer.
 
   [
 
+    [[link boost_asio.reference.windows__basic_overlapped_handle__rebind_executor [*rebind_executor]]]
+    [Rebinds the handle type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.windows__basic_overlapped_handle.executor_type [*executor_type]]]
     [The type of the executor associated with the object. ]
   
@@ -115539,6 +118151,184 @@ This function destroys the handle, cancelling any outstanding asynchronous wait
 
 [endsect]
 
+[section:windows__basic_overlapped_handle__rebind_executor windows::basic_overlapped_handle::rebind_executor]
+
+
+Rebinds the handle type to another executor. 
+
+
+  template<
+      typename ``[link boost_asio.reference.Executor1 Executor1]``>
+  struct rebind_executor
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.windows__basic_overlapped_handle__rebind_executor.other [*other]]]
+    [The handle type when rebound to the specified executor. ]
+  
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^boost/asio/windows/basic_overlapped_handle.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[section:other windows::basic_overlapped_handle::rebind_executor::other]
+
+[indexterm2 boost_asio.indexterm.windows__basic_overlapped_handle__rebind_executor.other..other..windows::basic_overlapped_handle::rebind_executor] 
+The handle type when rebound to the specified executor. 
+
+
+  typedef basic_overlapped_handle< Executor1 > other;
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.windows__basic_overlapped_handle__rebind_executor [*rebind_executor]]]
+    [Rebinds the handle type to another executor. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.windows__basic_overlapped_handle.executor_type [*executor_type]]]
+    [The type of the executor associated with the object. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.windows__basic_overlapped_handle.lowest_layer_type [*lowest_layer_type]]]
+    [An overlapped_handle is always the lowest layer. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.windows__basic_overlapped_handle.native_handle_type [*native_handle_type]]]
+    [The native representation of a handle. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.windows__basic_overlapped_handle.assign [*assign]]]
+    [Assign an existing native handle to the handle. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_overlapped_handle.basic_overlapped_handle [*basic_overlapped_handle]]]
+    [Construct an overlapped handle without opening it. 
+     [hr]
+     Construct an overlapped handle on an existing native handle. 
+     [hr]
+     Move-construct an overlapped handle from another. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_overlapped_handle.cancel [*cancel]]]
+    [Cancel all asynchronous operations associated with the handle. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_overlapped_handle.close [*close]]]
+    [Close the handle. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_overlapped_handle.get_executor [*get_executor]]]
+    [Get the executor associated with the object. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_overlapped_handle.is_open [*is_open]]]
+    [Determine whether the handle is open. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_overlapped_handle.lowest_layer [*lowest_layer]]]
+    [Get a reference to the lowest layer. 
+     [hr]
+     Get a const reference to the lowest layer. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_overlapped_handle.native_handle [*native_handle]]]
+    [Get the native handle representation. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_overlapped_handle.operator_eq_ [*operator=]]]
+    [Move-assign an overlapped handle from another. ]
+  ]
+  
+]
+
+[heading Protected Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.windows__basic_overlapped_handle._basic_overlapped_handle [*~basic_overlapped_handle]]]
+    [Protected destructor to prevent deletion through this type. ]
+  ]
+  
+]
+
+[heading Protected Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.windows__basic_overlapped_handle.impl_ [*impl_]]]
+    []
+  ]
+
+]
+
+The [link boost_asio.reference.windows__overlapped_handle `windows::overlapped_handle`] class provides the ability to wrap a Windows handle. The underlying object referred to by the handle must support overlapped I/O.
+
+
+[heading Thread Safety]
+  
+['Distinct] ['objects:] Safe.
+
+['Shared] ['objects:] Unsafe. 
+
+
+
+
+[heading Requirements]
+
+['Header: ][^boost/asio/windows/basic_overlapped_handle.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
 [section:windows__basic_random_access_handle windows::basic_random_access_handle]
 
 
@@ -115557,6 +118347,13 @@ Provides random-access handle functionality.
 
   [
 
+    [[link boost_asio.reference.windows__basic_random_access_handle__rebind_executor [*rebind_executor]]]
+    [Rebinds the handle type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.windows__basic_random_access_handle.executor_type [*executor_type]]]
     [The type of the executor associated with the object. ]
   
@@ -115746,11 +118543,11 @@ Start an asynchronous read at the specified offset.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some_at(
       uint64_t offset,
       const MutableBufferSequence & buffers,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously read data from the random-access handle. The function call always returns immediately.
@@ -115806,11 +118603,11 @@ Start an asynchronous write at the specified offset.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some_at(
       uint64_t offset,
       const ConstBufferSequence & buffers,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously write data to the random-access handle. The function call always returns immediately.
@@ -116398,6 +119195,13 @@ An overlapped\_handle is always the lowest layer.
 
   [
 
+    [[link boost_asio.reference.windows__basic_overlapped_handle__rebind_executor [*rebind_executor]]]
+    [Rebinds the handle type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.windows__basic_overlapped_handle.executor_type [*executor_type]]]
     [The type of the executor associated with the object. ]
   
@@ -116865,6 +119669,193 @@ The write\_some operation may not transmit all of the data to the peer. Consider
 
 [endsect]
 
+[section:windows__basic_random_access_handle__rebind_executor windows::basic_random_access_handle::rebind_executor]
+
+
+Rebinds the handle type to another executor. 
+
+
+  template<
+      typename ``[link boost_asio.reference.Executor1 Executor1]``>
+  struct rebind_executor
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.windows__basic_random_access_handle__rebind_executor.other [*other]]]
+    [The handle type when rebound to the specified executor. ]
+  
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^boost/asio/windows/basic_random_access_handle.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[section:other windows::basic_random_access_handle::rebind_executor::other]
+
+[indexterm2 boost_asio.indexterm.windows__basic_random_access_handle__rebind_executor.other..other..windows::basic_random_access_handle::rebind_executor] 
+The handle type when rebound to the specified executor. 
+
+
+  typedef basic_random_access_handle< Executor1 > other;
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.windows__basic_random_access_handle__rebind_executor [*rebind_executor]]]
+    [Rebinds the handle type to another executor. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.windows__basic_random_access_handle.executor_type [*executor_type]]]
+    [The type of the executor associated with the object. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.windows__basic_random_access_handle.lowest_layer_type [*lowest_layer_type]]]
+    [An overlapped_handle is always the lowest layer. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.windows__basic_random_access_handle.native_handle_type [*native_handle_type]]]
+    [The native representation of a handle. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.windows__basic_random_access_handle.assign [*assign]]]
+    [Assign an existing native handle to the handle. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_random_access_handle.async_read_some_at [*async_read_some_at]]]
+    [Start an asynchronous read at the specified offset. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_random_access_handle.async_write_some_at [*async_write_some_at]]]
+    [Start an asynchronous write at the specified offset. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_random_access_handle.basic_random_access_handle [*basic_random_access_handle]]]
+    [Construct a random-access handle without opening it. 
+     [hr]
+     Construct a random-access handle on an existing native handle. 
+     [hr]
+     Move-construct a random-access handle from another. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_random_access_handle.cancel [*cancel]]]
+    [Cancel all asynchronous operations associated with the handle. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_random_access_handle.close [*close]]]
+    [Close the handle. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_random_access_handle.get_executor [*get_executor]]]
+    [Get the executor associated with the object. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_random_access_handle.is_open [*is_open]]]
+    [Determine whether the handle is open. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_random_access_handle.lowest_layer [*lowest_layer]]]
+    [Get a reference to the lowest layer. 
+     [hr]
+     Get a const reference to the lowest layer. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_random_access_handle.native_handle [*native_handle]]]
+    [Get the native handle representation. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_random_access_handle.operator_eq_ [*operator=]]]
+    [Move-assign a random-access handle from another. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_random_access_handle.read_some_at [*read_some_at]]]
+    [Read some data from the handle at the specified offset. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_random_access_handle.write_some_at [*write_some_at]]]
+    [Write some data to the handle at the specified offset. ]
+  ]
+  
+]
+
+[heading Protected Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.windows__basic_random_access_handle.impl_ [*impl_]]]
+    []
+  ]
+
+]
+
+The [link boost_asio.reference.windows__basic_random_access_handle `windows::basic_random_access_handle`] class provides asynchronous and blocking random-access handle functionality.
+
+
+[heading Thread Safety]
+  
+['Distinct] ['objects:] Safe.
+
+['Shared] ['objects:] Unsafe. 
+
+
+
+
+[heading Requirements]
+
+['Header: ][^boost/asio/windows/basic_random_access_handle.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
 [section:windows__basic_stream_handle windows::basic_stream_handle]
 
 
@@ -116883,6 +119874,13 @@ Provides stream-oriented handle functionality.
 
   [
 
+    [[link boost_asio.reference.windows__basic_stream_handle__rebind_executor [*rebind_executor]]]
+    [Rebinds the handle type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.windows__basic_stream_handle.executor_type [*executor_type]]]
     [The type of the executor associated with the object. ]
   
@@ -117073,10 +120071,10 @@ Start an asynchronous read.
 
   template<
       typename ``[link boost_asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link boost_asio.reference.ReadHandler ReadHandler]``>
+      typename ``[link boost_asio.reference.ReadHandler ReadHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some(
       const MutableBufferSequence & buffers,
-      ReadHandler && handler);
+      ReadHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously read data from the stream handle. The function call always returns immediately.
@@ -117130,10 +120128,10 @@ Start an asynchronous write.
 
   template<
       typename ``[link boost_asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link boost_asio.reference.WriteHandler WriteHandler]``>
+      typename ``[link boost_asio.reference.WriteHandler WriteHandler]`` = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
   ``[link boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some(
       const ConstBufferSequence & buffers,
-      WriteHandler && handler);
+      WriteHandler && handler = ``[link boost_asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
 
 
 This function is used to asynchronously write data to the stream handle. The function call always returns immediately.
@@ -117719,6 +120717,13 @@ An overlapped\_handle is always the lowest layer.
 
   [
 
+    [[link boost_asio.reference.windows__basic_overlapped_handle__rebind_executor [*rebind_executor]]]
+    [Rebinds the handle type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.windows__basic_overlapped_handle.executor_type [*executor_type]]]
     [The type of the executor associated with the object. ]
   
@@ -118170,6 +121175,194 @@ The write\_some operation may not transmit all of the data to the peer. Consider
 
 [endsect]
 
+[section:windows__basic_stream_handle__rebind_executor windows::basic_stream_handle::rebind_executor]
+
+
+Rebinds the handle type to another executor. 
+
+
+  template<
+      typename ``[link boost_asio.reference.Executor1 Executor1]``>
+  struct rebind_executor
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.windows__basic_stream_handle__rebind_executor.other [*other]]]
+    [The handle type when rebound to the specified executor. ]
+  
+  ]
+
+]
+
+[heading Requirements]
+
+['Header: ][^boost/asio/windows/basic_stream_handle.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[section:other windows::basic_stream_handle::rebind_executor::other]
+
+[indexterm2 boost_asio.indexterm.windows__basic_stream_handle__rebind_executor.other..other..windows::basic_stream_handle::rebind_executor] 
+The handle type when rebound to the specified executor. 
+
+
+  typedef basic_stream_handle< Executor1 > other;
+
+
+[heading Types]
+[table
+  [[Name][Description]]
+
+  [
+
+    [[link boost_asio.reference.windows__basic_stream_handle__rebind_executor [*rebind_executor]]]
+    [Rebinds the handle type to another executor. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.windows__basic_stream_handle.executor_type [*executor_type]]]
+    [The type of the executor associated with the object. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.windows__basic_stream_handle.lowest_layer_type [*lowest_layer_type]]]
+    [An overlapped_handle is always the lowest layer. ]
+  
+  ]
+
+  [
+
+    [[link boost_asio.reference.windows__basic_stream_handle.native_handle_type [*native_handle_type]]]
+    [The native representation of a handle. ]
+  
+  ]
+
+]
+
+[heading Member Functions]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.windows__basic_stream_handle.assign [*assign]]]
+    [Assign an existing native handle to the handle. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_stream_handle.async_read_some [*async_read_some]]]
+    [Start an asynchronous read. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_stream_handle.async_write_some [*async_write_some]]]
+    [Start an asynchronous write. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_stream_handle.basic_stream_handle [*basic_stream_handle]]]
+    [Construct a stream handle without opening it. 
+     [hr]
+     Construct a stream handle on an existing native handle. 
+     [hr]
+     Move-construct a stream handle from another. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_stream_handle.cancel [*cancel]]]
+    [Cancel all asynchronous operations associated with the handle. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_stream_handle.close [*close]]]
+    [Close the handle. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_stream_handle.get_executor [*get_executor]]]
+    [Get the executor associated with the object. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_stream_handle.is_open [*is_open]]]
+    [Determine whether the handle is open. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_stream_handle.lowest_layer [*lowest_layer]]]
+    [Get a reference to the lowest layer. 
+     [hr]
+     Get a const reference to the lowest layer. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_stream_handle.native_handle [*native_handle]]]
+    [Get the native handle representation. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_stream_handle.operator_eq_ [*operator=]]]
+    [Move-assign a stream handle from another. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_stream_handle.read_some [*read_some]]]
+    [Read some data from the handle. ]
+  ]
+  
+  [
+    [[link boost_asio.reference.windows__basic_stream_handle.write_some [*write_some]]]
+    [Write some data to the handle. ]
+  ]
+  
+]
+
+[heading Protected Data Members]
+[table
+  [[Name][Description]]
+
+  [
+    [[link boost_asio.reference.windows__basic_stream_handle.impl_ [*impl_]]]
+    []
+  ]
+
+]
+
+The [link boost_asio.reference.windows__basic_stream_handle `windows::basic_stream_handle`] class provides asynchronous and blocking stream-oriented handle functionality.
+
+
+[heading Thread Safety]
+  
+['Distinct] ['objects:] Safe.
+
+['Shared] ['objects:] Unsafe.
+
+
+
+
+
+[heading Requirements]
+
+['Header: ][^boost/asio/windows/basic_stream_handle.hpp]
+
+['Convenience header: ][^boost/asio.hpp]
+
+
+[endsect]
+
+
+
+[endsect]
+
 
 [section:windows__object_handle windows::object_handle]
 
@@ -118186,6 +121379,13 @@ Typedef for the typical usage of an object handle.
 
   [
 
+    [[link boost_asio.reference.windows__basic_object_handle__rebind_executor [*rebind_executor]]]
+    [Rebinds the handle type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.windows__basic_object_handle.executor_type [*executor_type]]]
     [The type of the executor associated with the object. ]
   
@@ -118312,6 +121512,13 @@ Typedef for the typical usage of an overlapped handle.
 
   [
 
+    [[link boost_asio.reference.windows__basic_overlapped_handle__rebind_executor [*rebind_executor]]]
+    [Rebinds the handle type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.windows__basic_overlapped_handle.executor_type [*executor_type]]]
     [The type of the executor associated with the object. ]
   
@@ -118780,6 +121987,13 @@ Typedef for the typical usage of a random-access handle.
 
   [
 
+    [[link boost_asio.reference.windows__basic_random_access_handle__rebind_executor [*rebind_executor]]]
+    [Rebinds the handle type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.windows__basic_random_access_handle.executor_type [*executor_type]]]
     [The type of the executor associated with the object. ]
   
@@ -118927,6 +122141,13 @@ Typedef for the typical usage of a stream-oriented handle.
 
   [
 
+    [[link boost_asio.reference.windows__basic_stream_handle__rebind_executor [*rebind_executor]]]
+    [Rebinds the handle type to another executor. ]
+  
+  ]
+
+  [
+
     [[link boost_asio.reference.windows__basic_stream_handle.executor_type [*executor_type]]]
     [The type of the executor associated with the object. ]