couchbase 4.4.1 → 4.4.3

package/deps/couchbase-cxx-cache/asio/{6a3b5a552ffb18a235024ec851619cfcb1337a98 → b710bc0ca14b231d20e983b02d27485125c7860e}/asio/asio/include/asio/read.hpp

@@ -184,6 +184,9 @@ std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
     CompletionCondition completion_condition,
     constraint_t<
       is_mutable_buffer_sequence<MutableBufferSequence>::value
+    > = 0,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
     > = 0);
 
 /// Attempt to read a certain amount of data from a stream before returning.
@@ -231,6 +234,9 @@ std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
     CompletionCondition completion_condition, asio::error_code& ec,
     constraint_t<
       is_mutable_buffer_sequence<MutableBufferSequence>::value
+    > = 0,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
     > = 0);
 
 #if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
@@ -355,6 +361,9 @@ std::size_t read(SyncReadStream& s,
     > = 0,
     constraint_t<
       !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
+    > = 0,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
     > = 0);
 
 /// Attempt to read a certain amount of data from a stream before returning.
@@ -404,6 +413,9 @@ std::size_t read(SyncReadStream& s,
     > = 0,
     constraint_t<
       !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
+    > = 0,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
     > = 0);
 
 #if !defined(ASIO_NO_EXTENSIONS)
@@ -506,7 +518,10 @@ std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
 template <typename SyncReadStream, typename Allocator,
     typename CompletionCondition>
 std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition);
+    CompletionCondition completion_condition,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
+    > = 0);
 
 /// Attempt to read a certain amount of data from a stream before returning.
 /**
@@ -547,7 +562,10 @@ std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
 template <typename SyncReadStream, typename Allocator,
     typename CompletionCondition>
 std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, asio::error_code& ec);
+    CompletionCondition completion_condition, asio::error_code& ec,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
+    > = 0);
 
 #endif // !defined(ASIO_NO_IOSTREAM)
 #endif // !defined(ASIO_NO_EXTENSIONS)
@@ -661,6 +679,9 @@ std::size_t read(SyncReadStream& s, DynamicBuffer_v2 buffers,
     CompletionCondition completion_condition,
     constraint_t<
       is_dynamic_buffer_v2<DynamicBuffer_v2>::value
+    > = 0,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
     > = 0);
 
 /// Attempt to read a certain amount of data from a stream before returning.
@@ -706,6 +727,9 @@ std::size_t read(SyncReadStream& s, DynamicBuffer_v2 buffers,
     CompletionCondition completion_condition, asio::error_code& ec,
     constraint_t<
       is_dynamic_buffer_v2<DynamicBuffer_v2>::value
+    > = 0,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
     > = 0);
 
 /*@}*/
@@ -762,7 +786,7 @@ std::size_t read(SyncReadStream& s, DynamicBuffer_v2 buffers,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::post().
+ * manner equivalent to using asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(asio::error_code, std::size_t) @endcode
@@ -797,17 +821,26 @@ template <typename AsyncReadStream, typename MutableBufferSequence,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
       std::size_t)) ReadToken = default_completion_token_t<
         typename AsyncReadStream::executor_type>>
-auto async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
+inline auto async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
     ReadToken&& token = default_completion_token_t<
       typename AsyncReadStream::executor_type>(),
     constraint_t<
       is_mutable_buffer_sequence<MutableBufferSequence>::value
+    > = 0,
+    constraint_t<
+      !is_completion_condition<ReadToken>::value
     > = 0)
   -> decltype(
     async_initiate<ReadToken,
       void (asio::error_code, std::size_t)>(
         declval<detail::initiate_async_read<AsyncReadStream>>(),
-        token, buffers, transfer_all()));
+        token, buffers, transfer_all()))
+{
+  return async_initiate<ReadToken,
+    void (asio::error_code, std::size_t)>(
+      detail::initiate_async_read<AsyncReadStream>(s),
+      token, buffers, transfer_all());
+}
 
 /// Start an asynchronous operation to read a certain amount of data from a
 /// stream.
@@ -862,7 +895,7 @@ auto async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::post().
+ * manner equivalent to using asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(asio::error_code, std::size_t) @endcode
@@ -893,19 +926,28 @@ template <typename AsyncReadStream,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
       std::size_t)) ReadToken = default_completion_token_t<
         typename AsyncReadStream::executor_type>>
-auto async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
+inline auto async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
     CompletionCondition completion_condition,
     ReadToken&& token = default_completion_token_t<
       typename AsyncReadStream::executor_type>(),
     constraint_t<
       is_mutable_buffer_sequence<MutableBufferSequence>::value
+    > = 0,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
     > = 0)
   -> decltype(
     async_initiate<ReadToken,
       void (asio::error_code, std::size_t)>(
         declval<detail::initiate_async_read<AsyncReadStream>>(),
         token, buffers,
-        static_cast<CompletionCondition&&>(completion_condition)));
+        static_cast<CompletionCondition&&>(completion_condition)))
+{
+  return async_initiate<ReadToken,
+    void (asio::error_code, std::size_t)>(
+      detail::initiate_async_read<AsyncReadStream>(s), token, buffers,
+      static_cast<CompletionCondition&&>(completion_condition));
+}
 
 #if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
 
@@ -953,7 +995,7 @@ auto async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::post().
+ * manner equivalent to using asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(asio::error_code, std::size_t) @endcode
@@ -979,7 +1021,7 @@ template <typename AsyncReadStream, typename DynamicBuffer_v1,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
       std::size_t)) ReadToken = default_completion_token_t<
         typename AsyncReadStream::executor_type>>
-auto async_read(AsyncReadStream& s, DynamicBuffer_v1&& buffers,
+inline auto async_read(AsyncReadStream& s, DynamicBuffer_v1&& buffers,
     ReadToken&& token = default_completion_token_t<
       typename AsyncReadStream::executor_type>(),
     constraint_t<
@@ -987,12 +1029,21 @@ auto async_read(AsyncReadStream& s, DynamicBuffer_v1&& buffers,
     > = 0,
     constraint_t<
       !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
+    > = 0,
+    constraint_t<
+      !is_completion_condition<ReadToken>::value
     > = 0)
   -> decltype(
     async_initiate<ReadToken,
       void (asio::error_code, std::size_t)>(
         declval<detail::initiate_async_read_dynbuf_v1<AsyncReadStream>>(),
-        token, static_cast<DynamicBuffer_v1&&>(buffers), transfer_all()));
+        token, static_cast<DynamicBuffer_v1&&>(buffers), transfer_all()))
+{
+  return async_initiate<ReadToken,
+    void (asio::error_code, std::size_t)>(
+      detail::initiate_async_read_dynbuf_v1<AsyncReadStream>(s),
+      token, static_cast<DynamicBuffer_v1&&>(buffers), transfer_all());
+}
 
 /// Start an asynchronous operation to read a certain amount of data from a
 /// stream.
@@ -1052,7 +1103,7 @@ auto async_read(AsyncReadStream& s, DynamicBuffer_v1&& buffers,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::post().
+ * manner equivalent to using asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(asio::error_code, std::size_t) @endcode
@@ -1073,7 +1124,7 @@ template <typename AsyncReadStream,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
       std::size_t)) ReadToken = default_completion_token_t<
         typename AsyncReadStream::executor_type>>
-auto async_read(AsyncReadStream& s, DynamicBuffer_v1&& buffers,
+inline auto async_read(AsyncReadStream& s, DynamicBuffer_v1&& buffers,
     CompletionCondition completion_condition,
     ReadToken&& token = default_completion_token_t<
       typename AsyncReadStream::executor_type>(),
@@ -1082,13 +1133,23 @@ auto async_read(AsyncReadStream& s, DynamicBuffer_v1&& buffers,
     > = 0,
     constraint_t<
       !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
+    > = 0,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
     > = 0)
   -> decltype(
     async_initiate<ReadToken,
       void (asio::error_code, std::size_t)>(
         declval<detail::initiate_async_read_dynbuf_v1<AsyncReadStream>>(),
         token, static_cast<DynamicBuffer_v1&&>(buffers),
-        static_cast<CompletionCondition&&>(completion_condition)));
+        static_cast<CompletionCondition&&>(completion_condition)))
+{
+  return async_initiate<ReadToken,
+    void (asio::error_code, std::size_t)>(
+      detail::initiate_async_read_dynbuf_v1<AsyncReadStream>(s),
+      token, static_cast<DynamicBuffer_v1&&>(buffers),
+      static_cast<CompletionCondition&&>(completion_condition));
+}
 
 #if !defined(ASIO_NO_EXTENSIONS)
 #if !defined(ASIO_NO_IOSTREAM)
@@ -1135,7 +1196,7 @@ auto async_read(AsyncReadStream& s, DynamicBuffer_v1&& buffers,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::post().
+ * manner equivalent to using asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(asio::error_code, std::size_t) @endcode
@@ -1161,14 +1222,23 @@ template <typename AsyncReadStream, typename Allocator,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
       std::size_t)) ReadToken = default_completion_token_t<
         typename AsyncReadStream::executor_type>>
-auto async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
+inline auto async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
     ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>())
+      typename AsyncReadStream::executor_type>(),
+    constraint_t<
+      !is_completion_condition<ReadToken>::value
+    > = 0)
   -> decltype(
     async_initiate<ReadToken,
       void (asio::error_code, std::size_t)>(
         declval<detail::initiate_async_read_dynbuf_v1<AsyncReadStream>>(),
-        token, basic_streambuf_ref<Allocator>(b), transfer_all()));
+        token, basic_streambuf_ref<Allocator>(b), transfer_all()))
+{
+  return async_initiate<ReadToken,
+    void (asio::error_code, std::size_t)>(
+      detail::initiate_async_read_dynbuf_v1<AsyncReadStream>(s),
+      token, basic_streambuf_ref<Allocator>(b), transfer_all());
+}
 
 /// Start an asynchronous operation to read a certain amount of data from a
 /// stream.
@@ -1226,7 +1296,7 @@ auto async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::post().
+ * manner equivalent to using asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(asio::error_code, std::size_t) @endcode
@@ -1247,16 +1317,26 @@ template <typename AsyncReadStream,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
       std::size_t)) ReadToken = default_completion_token_t<
         typename AsyncReadStream::executor_type>>
-auto async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
+inline auto async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition,
     ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>())
+      typename AsyncReadStream::executor_type>(),
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
+    > = 0)
   -> decltype(
     async_initiate<ReadToken,
       void (asio::error_code, std::size_t)>(
         declval<detail::initiate_async_read_dynbuf_v1<AsyncReadStream>>(),
         token, basic_streambuf_ref<Allocator>(b),
-        static_cast<CompletionCondition&&>(completion_condition)));
+        static_cast<CompletionCondition&&>(completion_condition)))
+{
+  return async_initiate<ReadToken,
+    void (asio::error_code, std::size_t)>(
+      detail::initiate_async_read_dynbuf_v1<AsyncReadStream>(s),
+      token, basic_streambuf_ref<Allocator>(b),
+      static_cast<CompletionCondition&&>(completion_condition));
+}
 
 #endif // !defined(ASIO_NO_IOSTREAM)
 #endif // !defined(ASIO_NO_EXTENSIONS)
@@ -1306,7 +1386,7 @@ auto async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::post().
+ * manner equivalent to using asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(asio::error_code, std::size_t) @endcode
@@ -1332,17 +1412,26 @@ template <typename AsyncReadStream, typename DynamicBuffer_v2,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
       std::size_t)) ReadToken = default_completion_token_t<
         typename AsyncReadStream::executor_type>>
-auto async_read(AsyncReadStream& s, DynamicBuffer_v2 buffers,
+inline auto async_read(AsyncReadStream& s, DynamicBuffer_v2 buffers,
     ReadToken&& token = default_completion_token_t<
       typename AsyncReadStream::executor_type>(),
     constraint_t<
       is_dynamic_buffer_v2<DynamicBuffer_v2>::value
+    > = 0,
+    constraint_t<
+      !is_completion_condition<ReadToken>::value
     > = 0)
   -> decltype(
     async_initiate<ReadToken,
       void (asio::error_code, std::size_t)>(
         declval<detail::initiate_async_read_dynbuf_v2<AsyncReadStream>>(),
-        token, static_cast<DynamicBuffer_v2&&>(buffers), transfer_all()));
+        token, static_cast<DynamicBuffer_v2&&>(buffers), transfer_all()))
+{
+  return async_initiate<ReadToken,
+    void (asio::error_code, std::size_t)>(
+      detail::initiate_async_read_dynbuf_v2<AsyncReadStream>(s),
+      token, static_cast<DynamicBuffer_v2&&>(buffers), transfer_all());
+}
 
 /// Start an asynchronous operation to read a certain amount of data from a
 /// stream.
@@ -1402,7 +1491,7 @@ auto async_read(AsyncReadStream& s, DynamicBuffer_v2 buffers,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::post().
+ * manner equivalent to using asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(asio::error_code, std::size_t) @endcode
@@ -1423,19 +1512,29 @@ template <typename AsyncReadStream,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
       std::size_t)) ReadToken = default_completion_token_t<
         typename AsyncReadStream::executor_type>>
-auto async_read(AsyncReadStream& s, DynamicBuffer_v2 buffers,
+inline auto async_read(AsyncReadStream& s, DynamicBuffer_v2 buffers,
     CompletionCondition completion_condition,
     ReadToken&& token = default_completion_token_t<
       typename AsyncReadStream::executor_type>(),
     constraint_t<
       is_dynamic_buffer_v2<DynamicBuffer_v2>::value
+    > = 0,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
     > = 0)
   -> decltype(
     async_initiate<ReadToken,
       void (asio::error_code, std::size_t)>(
         declval<detail::initiate_async_read_dynbuf_v2<AsyncReadStream>>(),
         token, static_cast<DynamicBuffer_v2&&>(buffers),
-        static_cast<CompletionCondition&&>(completion_condition)));
+        static_cast<CompletionCondition&&>(completion_condition)))
+{
+  return async_initiate<ReadToken,
+    void (asio::error_code, std::size_t)>(
+      detail::initiate_async_read_dynbuf_v2<AsyncReadStream>(s),
+      token, static_cast<DynamicBuffer_v2&&>(buffers),
+      static_cast<CompletionCondition&&>(completion_condition));
+}
 
 /*@}*/
 

package/deps/couchbase-cxx-cache/asio/{6a3b5a552ffb18a235024ec851619cfcb1337a98 → b710bc0ca14b231d20e983b02d27485125c7860e}/asio/asio/include/asio/read_at.hpp

@@ -190,7 +190,10 @@ template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
     typename CompletionCondition>
 std::size_t read_at(SyncRandomAccessReadDevice& d,
     uint64_t offset, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition);
+    CompletionCondition completion_condition,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
+    > = 0);
 
 /// Attempt to read a certain amount of data at the specified offset before
 /// returning.
@@ -239,7 +242,10 @@ template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
     typename CompletionCondition>
 std::size_t read_at(SyncRandomAccessReadDevice& d,
     uint64_t offset, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition, asio::error_code& ec);
+    CompletionCondition completion_condition, asio::error_code& ec,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
+    > = 0);
 
 #if !defined(ASIO_NO_EXTENSIONS)
 #if !defined(ASIO_NO_IOSTREAM)
@@ -350,7 +356,10 @@ template <typename SyncRandomAccessReadDevice, typename Allocator,
     typename CompletionCondition>
 std::size_t read_at(SyncRandomAccessReadDevice& d,
     uint64_t offset, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition);
+    CompletionCondition completion_condition,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
+    > = 0);
 
 /// Attempt to read a certain amount of data at the specified offset before
 /// returning.
@@ -394,7 +403,10 @@ template <typename SyncRandomAccessReadDevice, typename Allocator,
     typename CompletionCondition>
 std::size_t read_at(SyncRandomAccessReadDevice& d,
     uint64_t offset, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, asio::error_code& ec);
+    CompletionCondition completion_condition, asio::error_code& ec,
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
+    > = 0);
 
 #endif // !defined(ASIO_NO_IOSTREAM)
 #endif // !defined(ASIO_NO_EXTENSIONS)
@@ -453,7 +465,7 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::post().
+ * manner equivalent to using asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(asio::error_code, std::size_t) @endcode
@@ -488,15 +500,24 @@ template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
       std::size_t)) ReadToken = default_completion_token_t<
         typename AsyncRandomAccessReadDevice::executor_type>>
-auto async_read_at(AsyncRandomAccessReadDevice& d,
+inline auto async_read_at(AsyncRandomAccessReadDevice& d,
     uint64_t offset, const MutableBufferSequence& buffers,
     ReadToken&& token = default_completion_token_t<
-      typename AsyncRandomAccessReadDevice::executor_type>())
+      typename AsyncRandomAccessReadDevice::executor_type>(),
+    constraint_t<
+      !is_completion_condition<ReadToken>::value
+    > = 0)
   -> decltype(
     async_initiate<ReadToken,
       void (asio::error_code, std::size_t)>(
         declval<detail::initiate_async_read_at<AsyncRandomAccessReadDevice>>(),
-        token, offset, buffers, transfer_all()));
+        token, offset, buffers, transfer_all()))
+{
+  return async_initiate<ReadToken,
+    void (asio::error_code, std::size_t)>(
+      detail::initiate_async_read_at<AsyncRandomAccessReadDevice>(d),
+      token, offset, buffers, transfer_all());
+}
 
 /// Start an asynchronous operation to read a certain amount of data at the
 /// specified offset.
@@ -554,7 +575,7 @@ auto async_read_at(AsyncRandomAccessReadDevice& d,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::post().
+ * manner equivalent to using asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(asio::error_code, std::size_t) @endcode
@@ -585,17 +606,27 @@ template <typename AsyncRandomAccessReadDevice,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
       std::size_t)) ReadToken = default_completion_token_t<
         typename AsyncRandomAccessReadDevice::executor_type>>
-auto async_read_at(AsyncRandomAccessReadDevice& d,
+inline auto async_read_at(AsyncRandomAccessReadDevice& d,
     uint64_t offset, const MutableBufferSequence& buffers,
     CompletionCondition completion_condition,
     ReadToken&& token = default_completion_token_t<
-      typename AsyncRandomAccessReadDevice::executor_type>())
+      typename AsyncRandomAccessReadDevice::executor_type>(),
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
+    > = 0)
   -> decltype(
     async_initiate<ReadToken,
       void (asio::error_code, std::size_t)>(
         declval<detail::initiate_async_read_at<AsyncRandomAccessReadDevice>>(),
         token, offset, buffers,
-        static_cast<CompletionCondition&&>(completion_condition)));
+        static_cast<CompletionCondition&&>(completion_condition)))
+{
+  return async_initiate<ReadToken,
+    void (asio::error_code, std::size_t)>(
+      detail::initiate_async_read_at<AsyncRandomAccessReadDevice>(d),
+      token, offset, buffers,
+      static_cast<CompletionCondition&&>(completion_condition));
+}
 
 #if !defined(ASIO_NO_EXTENSIONS)
 #if !defined(ASIO_NO_IOSTREAM)
@@ -640,7 +671,7 @@ auto async_read_at(AsyncRandomAccessReadDevice& d,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::post().
+ * manner equivalent to using asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(asio::error_code, std::size_t) @endcode
@@ -666,16 +697,25 @@ template <typename AsyncRandomAccessReadDevice, typename Allocator,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
       std::size_t)) ReadToken = default_completion_token_t<
         typename AsyncRandomAccessReadDevice::executor_type>>
-auto async_read_at(AsyncRandomAccessReadDevice& d,
+inline auto async_read_at(AsyncRandomAccessReadDevice& d,
     uint64_t offset, basic_streambuf<Allocator>& b,
     ReadToken&& token = default_completion_token_t<
-      typename AsyncRandomAccessReadDevice::executor_type>())
+      typename AsyncRandomAccessReadDevice::executor_type>(),
+    constraint_t<
+      !is_completion_condition<ReadToken>::value
+    > = 0)
   -> decltype(
     async_initiate<ReadToken,
       void (asio::error_code, std::size_t)>(
         declval<detail::initiate_async_read_at_streambuf<
           AsyncRandomAccessReadDevice>>(),
-        token, offset, &b, transfer_all()));
+        token, offset, &b, transfer_all()))
+{
+  return async_initiate<ReadToken,
+    void (asio::error_code, std::size_t)>(
+      detail::initiate_async_read_at_streambuf<AsyncRandomAccessReadDevice>(d),
+      token, offset, &b, transfer_all());
+}
 
 /// Start an asynchronous operation to read a certain amount of data at the
 /// specified offset.
@@ -731,7 +771,7 @@ auto async_read_at(AsyncRandomAccessReadDevice& d,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the completion handler will not be invoked from within this function.
  * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::post().
+ * manner equivalent to using asio::async_immediate().
  *
  * @par Completion Signature
  * @code void(asio::error_code, std::size_t) @endcode
@@ -752,17 +792,27 @@ template <typename AsyncRandomAccessReadDevice,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
       std::size_t)) ReadToken = default_completion_token_t<
         typename AsyncRandomAccessReadDevice::executor_type>>
-auto async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
+inline auto async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
     basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
     ReadToken&& token = default_completion_token_t<
-      typename AsyncRandomAccessReadDevice::executor_type>())
+      typename AsyncRandomAccessReadDevice::executor_type>(),
+    constraint_t<
+      is_completion_condition<CompletionCondition>::value
+    > = 0)
   -> decltype(
     async_initiate<ReadToken,
       void (asio::error_code, std::size_t)>(
         declval<detail::initiate_async_read_at_streambuf<
           AsyncRandomAccessReadDevice>>(),
         token, offset, &b,
-        static_cast<CompletionCondition&&>(completion_condition)));
+        static_cast<CompletionCondition&&>(completion_condition)))
+{
+  return async_initiate<ReadToken,
+    void (asio::error_code, std::size_t)>(
+      detail::initiate_async_read_at_streambuf<AsyncRandomAccessReadDevice>(d),
+      token, offset, &b,
+      static_cast<CompletionCondition&&>(completion_condition));
+}
 
 #endif // !defined(ASIO_NO_IOSTREAM)
 #endif // !defined(ASIO_NO_EXTENSIONS)