couchbase 4.2.0 → 4.2.1

package/deps/couchbase-cxx-client/third_party/asio/asio/include/asio/impl/post.hpp

@@ -2,7 +2,7 @@
 // impl/post.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -216,34 +216,44 @@ private:
 
 } // namespace detail
 
-template <ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken>
-ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) post(
-    ASIO_MOVE_ARG(CompletionToken) token)
+template <ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
+ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(NullaryToken, void()) post(
+    ASIO_MOVE_ARG(NullaryToken) token)
+  ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<NullaryToken, void()>(
+        declval<detail::initiate_post>(), token)))
 {
-  return async_initiate<CompletionToken, void()>(
+  return async_initiate<NullaryToken, void()>(
       detail::initiate_post(), token);
 }
 
 template <typename Executor,
-    ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken>
-ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) post(
-    const Executor& ex, ASIO_MOVE_ARG(CompletionToken) token,
+    ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
+ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(NullaryToken, void()) post(
+    const Executor& ex, ASIO_MOVE_ARG(NullaryToken) token,
     typename constraint<
       execution::is_executor<Executor>::value || is_executor<Executor>::value
     >::type)
+  ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<NullaryToken, void()>(
+        declval<detail::initiate_post_with_executor<Executor> >(), token)))
 {
-  return async_initiate<CompletionToken, void()>(
+  return async_initiate<NullaryToken, void()>(
       detail::initiate_post_with_executor<Executor>(ex), token);
 }
 
 template <typename ExecutionContext,
-    ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) post(
-    ExecutionContext& ctx, ASIO_MOVE_ARG(CompletionToken) token,
+    ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
+inline ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(NullaryToken, void()) post(
+    ExecutionContext& ctx, ASIO_MOVE_ARG(NullaryToken) token,
     typename constraint<is_convertible<
       ExecutionContext&, execution_context&>::value>::type)
+  ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<NullaryToken, void()>(
+        declval<detail::initiate_post_with_executor<
+          typename ExecutionContext::executor_type> >(), token)))
 {
-  return async_initiate<CompletionToken, void()>(
+  return async_initiate<NullaryToken, void()>(
       detail::initiate_post_with_executor<
         typename ExecutionContext::executor_type>(
           ctx.get_executor()), token);

package/deps/couchbase-cxx-client/third_party/asio/asio/include/asio/{experimental/impl → impl}/prepend.hpp

@@ -1,15 +1,15 @@
 //
-// experimental/impl/prepend.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// impl/prepend.hpp
+// ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#ifndef ASIO_IMPL_EXPERIMENTAL_PREPEND_HPP
-#define ASIO_IMPL_EXPERIMENTAL_PREPEND_HPP
+#ifndef ASIO_IMPL_PREPEND_HPP
+#define ASIO_IMPL_PREPEND_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -23,12 +23,12 @@
 #include "asio/detail/handler_cont_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
 #include "asio/detail/type_traits.hpp"
+#include "asio/detail/utility.hpp"
 #include "asio/detail/variadic_templates.hpp"
 
 #include "asio/detail/push_options.hpp"
 
 namespace asio {
-namespace experimental {
 namespace detail {
 
 // Class to adapt a prepend_t as a completion handler.
@@ -49,12 +49,12 @@ public:
   void operator()(ASIO_MOVE_ARG(Args)... args)
   {
     this->invoke(
-        std::make_index_sequence<sizeof...(Values)>{},
+        index_sequence_for<Values...>{},
         ASIO_MOVE_CAST(Args)(args)...);
   }
 
   template <std::size_t... I, typename... Args>
-  void invoke(std::index_sequence<I...>, ASIO_MOVE_ARG(Args)... args)
+  void invoke(index_sequence<I...>, ASIO_MOVE_ARG(Args)... args)
   {
     ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
         ASIO_MOVE_CAST(Values)(std::get<I>(values_))...,
@@ -134,18 +134,17 @@ struct prepend_signature<R(Args...), Values...>
 };
 
 } // namespace detail
-} // namespace experimental
 
 #if !defined(GENERATING_DOCUMENTATION)
 
 template <typename CompletionToken, typename... Values, typename Signature>
 struct async_result<
-    experimental::prepend_t<CompletionToken, Values...>, Signature>
+    prepend_t<CompletionToken, Values...>, Signature>
   : async_result<CompletionToken,
-      typename experimental::detail::prepend_signature<
+      typename detail::prepend_signature<
         Signature, Values...>::type>
 {
-  typedef typename experimental::detail::prepend_signature<
+  typedef typename detail::prepend_signature<
       Signature, Values...>::type signature;
 
   template <typename Initiation>
@@ -163,7 +162,7 @@ struct async_result<
         ASIO_MOVE_ARG(Args)... args)
     {
       ASIO_MOVE_CAST(Initiation)(initiation_)(
-          experimental::detail::prepend_handler<
+          detail::prepend_handler<
             typename decay<Handler>::type, Values...>(
               ASIO_MOVE_CAST(Handler)(handler),
               ASIO_MOVE_CAST(std::tuple<Values...>)(values)),
@@ -195,13 +194,13 @@ struct async_result<
 };
 
 template <template <typename, typename> class Associator,
-    typename Handler, typename DefaultCandidate>
+    typename Handler, typename... Values, typename DefaultCandidate>
 struct associator<Associator,
-    experimental::detail::prepend_handler<Handler>, DefaultCandidate>
+    detail::prepend_handler<Handler, Values...>, DefaultCandidate>
   : Associator<Handler, DefaultCandidate>
 {
   static typename Associator<Handler, DefaultCandidate>::type get(
-      const experimental::detail::prepend_handler<Handler>& h,
+      const detail::prepend_handler<Handler, Values...>& h,
       const DefaultCandidate& c = DefaultCandidate()) ASIO_NOEXCEPT
   {
     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
@@ -214,4 +213,4 @@ struct associator<Associator,
 
 #include "asio/detail/pop_options.hpp"
 
-#endif // ASIO_IMPL_EXPERIMENTAL_PREPEND_HPP
+#endif // ASIO_IMPL_PREPEND_HPP

package/deps/couchbase-cxx-client/third_party/asio/asio/include/asio/impl/read.hpp

@@ -2,7 +2,7 @@
 // impl/read.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,7 +18,6 @@
 #include <algorithm>
 #include "asio/associator.hpp"
 #include "asio/buffer.hpp"
-#include "asio/completion_condition.hpp"
 #include "asio/detail/array_fwd.hpp"
 #include "asio/detail/base_from_cancellation_state.hpp"
 #include "asio/detail/base_from_completion_cond.hpp"
@@ -42,7 +41,7 @@ namespace detail
 {
   template <typename SyncReadStream, typename MutableBufferSequence,
       typename MutableBufferIterator, typename CompletionCondition>
-  std::size_t read_buffer_sequence(SyncReadStream& s,
+  std::size_t read_buffer_seq(SyncReadStream& s,
       const MutableBufferSequence& buffers, const MutableBufferIterator&,
       CompletionCondition completion_condition, asio::error_code& ec)
   {
@@ -69,7 +68,7 @@ std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
       is_mutable_buffer_sequence<MutableBufferSequence>::value
     >::type)
 {
-  return detail::read_buffer_sequence(s, buffers,
+  return detail::read_buffer_seq(s, buffers,
       asio::buffer_sequence_begin(buffers),
       ASIO_MOVE_CAST(CompletionCondition)(completion_condition), ec);
 }
@@ -487,23 +486,23 @@ namespace detail
   template <typename AsyncReadStream, typename MutableBufferSequence,
       typename MutableBufferIterator, typename CompletionCondition,
       typename ReadHandler>
-  inline void start_read_buffer_sequence_op(AsyncReadStream& stream,
+  inline void start_read_op(AsyncReadStream& stream,
       const MutableBufferSequence& buffers, const MutableBufferIterator&,
       CompletionCondition& completion_condition, ReadHandler& handler)
   {
-    detail::read_op<AsyncReadStream, MutableBufferSequence,
+    read_op<AsyncReadStream, MutableBufferSequence,
       MutableBufferIterator, CompletionCondition, ReadHandler>(
         stream, buffers, completion_condition, handler)(
           asio::error_code(), 0, 1);
   }
 
   template <typename AsyncReadStream>
-  class initiate_async_read_buffer_sequence
+  class initiate_async_read
   {
   public:
     typedef typename AsyncReadStream::executor_type executor_type;
 
-    explicit initiate_async_read_buffer_sequence(AsyncReadStream& stream)
+    explicit initiate_async_read(AsyncReadStream& stream)
       : stream_(stream)
     {
     }
@@ -525,7 +524,7 @@ namespace detail
 
       non_const_lvalue<ReadHandler> handler2(handler);
       non_const_lvalue<CompletionCondition> completion_cond2(completion_cond);
-      start_read_buffer_sequence_op(stream_, buffers,
+      start_read_op(stream_, buffers,
           asio::buffer_sequence_begin(buffers),
           completion_cond2.value, handler2.value);
     }
@@ -561,37 +560,49 @@ struct associator<Associator,
 template <typename AsyncReadStream,
     typename MutableBufferSequence, typename CompletionCondition,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadHandler>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
     void (asio::error_code, std::size_t))
 async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
     CompletionCondition completion_condition,
-    ASIO_MOVE_ARG(ReadHandler) handler,
+    ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<
       is_mutable_buffer_sequence<MutableBufferSequence>::value
     >::type)
+  ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<ReadToken,
+      void (asio::error_code, std::size_t)>(
+        declval<detail::initiate_async_read<AsyncReadStream> >(),
+        token, buffers,
+        ASIO_MOVE_CAST(CompletionCondition)(completion_condition))))
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_buffer_sequence<AsyncReadStream>(s), handler,
-      buffers, ASIO_MOVE_CAST(CompletionCondition)(completion_condition));
+      detail::initiate_async_read<AsyncReadStream>(s),
+      token, buffers,
+      ASIO_MOVE_CAST(CompletionCondition)(completion_condition));
 }
 
 template <typename AsyncReadStream, typename MutableBufferSequence,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadHandler>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
     void (asio::error_code, std::size_t))
 async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
-    ASIO_MOVE_ARG(ReadHandler) handler,
+    ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<
       is_mutable_buffer_sequence<MutableBufferSequence>::value
     >::type)
+  ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<ReadToken,
+      void (asio::error_code, std::size_t)>(
+        declval<detail::initiate_async_read<AsyncReadStream> >(),
+        token, buffers, transfer_all())))
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_buffer_sequence<AsyncReadStream>(s),
-      handler, buffers, transfer_all());
+      detail::initiate_async_read<AsyncReadStream>(s),
+      token, buffers, transfer_all());
 }
 
 #if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
@@ -836,45 +847,59 @@ struct associator<Associator,
 
 template <typename AsyncReadStream, typename DynamicBuffer_v1,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadHandler>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
     void (asio::error_code, std::size_t))
 async_read(AsyncReadStream& s,
     ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
-    ASIO_MOVE_ARG(ReadHandler) handler,
+    ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<
       is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value
     >::type,
     typename constraint<
       !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value
     >::type)
+  ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<ReadToken,
+      void (asio::error_code, std::size_t)>(
+        declval<detail::initiate_async_read_dynbuf_v1<AsyncReadStream> >(),
+        token, ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),
+        transfer_all())))
 {
-  return async_read(s,
-      ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),
-      transfer_all(), ASIO_MOVE_CAST(ReadHandler)(handler));
+  return async_initiate<ReadToken,
+    void (asio::error_code, std::size_t)>(
+      detail::initiate_async_read_dynbuf_v1<AsyncReadStream>(s),
+      token, ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),
+      transfer_all());
 }
 
 template <typename AsyncReadStream,
     typename DynamicBuffer_v1, typename CompletionCondition,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadHandler>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
     void (asio::error_code, std::size_t))
 async_read(AsyncReadStream& s,
     ASIO_MOVE_ARG(DynamicBuffer_v1) buffers,
     CompletionCondition completion_condition,
-    ASIO_MOVE_ARG(ReadHandler) handler,
+    ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<
       is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value
     >::type,
     typename constraint<
       !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value
     >::type)
+  ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<ReadToken,
+      void (asio::error_code, std::size_t)>(
+        declval<detail::initiate_async_read_dynbuf_v1<AsyncReadStream> >(),
+        token, ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),
+        ASIO_MOVE_CAST(CompletionCondition)(completion_condition))))
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (asio::error_code, std::size_t)>(
       detail::initiate_async_read_dynbuf_v1<AsyncReadStream>(s),
-      handler, ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),
+      token, ASIO_MOVE_CAST(DynamicBuffer_v1)(buffers),
       ASIO_MOVE_CAST(CompletionCondition)(completion_condition));
 }
 
@@ -883,29 +908,36 @@ async_read(AsyncReadStream& s,
 
 template <typename AsyncReadStream, typename Allocator,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadHandler>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
     void (asio::error_code, std::size_t))
 async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
-    ASIO_MOVE_ARG(ReadHandler) handler)
+    ASIO_MOVE_ARG(ReadToken) token)
+  ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_read(s, basic_streambuf_ref<Allocator>(b),
+        ASIO_MOVE_CAST(ReadToken)(token))))
 {
   return async_read(s, basic_streambuf_ref<Allocator>(b),
-      ASIO_MOVE_CAST(ReadHandler)(handler));
+      ASIO_MOVE_CAST(ReadToken)(token));
 }
 
 template <typename AsyncReadStream,
     typename Allocator, typename CompletionCondition,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadHandler>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
     void (asio::error_code, std::size_t))
 async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition,
-    ASIO_MOVE_ARG(ReadHandler) handler)
+    ASIO_MOVE_ARG(ReadToken) token)
+  ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_read(s, basic_streambuf_ref<Allocator>(b),
+        ASIO_MOVE_CAST(CompletionCondition)(completion_condition),
+        ASIO_MOVE_CAST(ReadToken)(token))))
 {
   return async_read(s, basic_streambuf_ref<Allocator>(b),
       ASIO_MOVE_CAST(CompletionCondition)(completion_condition),
-      ASIO_MOVE_CAST(ReadHandler)(handler));
+      ASIO_MOVE_CAST(ReadToken)(token));
 }
 
 #endif // !defined(ASIO_NO_IOSTREAM)
@@ -1158,37 +1190,51 @@ struct associator<Associator,
 
 template <typename AsyncReadStream, typename DynamicBuffer_v2,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadHandler>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
     void (asio::error_code, std::size_t))
 async_read(AsyncReadStream& s, DynamicBuffer_v2 buffers,
-    ASIO_MOVE_ARG(ReadHandler) handler,
+    ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<
       is_dynamic_buffer_v2<DynamicBuffer_v2>::value
     >::type)
+  ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<ReadToken,
+      void (asio::error_code, std::size_t)>(
+        declval<detail::initiate_async_read_dynbuf_v2<AsyncReadStream> >(),
+        token, ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),
+        transfer_all())))
 {
-  return async_read(s,
-      ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),
-      transfer_all(), ASIO_MOVE_CAST(ReadHandler)(handler));
+  return async_initiate<ReadToken,
+    void (asio::error_code, std::size_t)>(
+      detail::initiate_async_read_dynbuf_v2<AsyncReadStream>(s),
+      token, ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),
+      transfer_all());
 }
 
 template <typename AsyncReadStream,
     typename DynamicBuffer_v2, typename CompletionCondition,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadHandler>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
     void (asio::error_code, std::size_t))
 async_read(AsyncReadStream& s, DynamicBuffer_v2 buffers,
     CompletionCondition completion_condition,
-    ASIO_MOVE_ARG(ReadHandler) handler,
+    ASIO_MOVE_ARG(ReadToken) token,
     typename constraint<
       is_dynamic_buffer_v2<DynamicBuffer_v2>::value
     >::type)
+  ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<ReadToken,
+      void (asio::error_code, std::size_t)>(
+        declval<detail::initiate_async_read_dynbuf_v2<AsyncReadStream> >(),
+        token, ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),
+        ASIO_MOVE_CAST(CompletionCondition)(completion_condition))))
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (asio::error_code, std::size_t)>(
       detail::initiate_async_read_dynbuf_v2<AsyncReadStream>(s),
-      handler, ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),
+      token, ASIO_MOVE_CAST(DynamicBuffer_v2)(buffers),
       ASIO_MOVE_CAST(CompletionCondition)(completion_condition));
 }
 

package/deps/couchbase-cxx-client/third_party/asio/asio/include/asio/impl/read_at.hpp

@@ -2,7 +2,7 @@
 // impl/read_at.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,7 +18,6 @@
 #include <algorithm>
 #include "asio/associator.hpp"
 #include "asio/buffer.hpp"
-#include "asio/completion_condition.hpp"
 #include "asio/detail/array_fwd.hpp"
 #include "asio/detail/base_from_cancellation_state.hpp"
 #include "asio/detail/base_from_completion_cond.hpp"
@@ -346,7 +345,7 @@ namespace detail
   template <typename AsyncRandomAccessReadDevice,
       typename MutableBufferSequence, typename MutableBufferIterator,
       typename CompletionCondition, typename ReadHandler>
-  inline void start_read_at_buffer_sequence_op(AsyncRandomAccessReadDevice& d,
+  inline void start_read_at_op(AsyncRandomAccessReadDevice& d,
       uint64_t offset, const MutableBufferSequence& buffers,
       const MutableBufferIterator&, CompletionCondition& completion_condition,
       ReadHandler& handler)
@@ -358,13 +357,12 @@ namespace detail
   }
 
   template <typename AsyncRandomAccessReadDevice>
-  class initiate_async_read_at_buffer_sequence
+  class initiate_async_read_at
   {
   public:
     typedef typename AsyncRandomAccessReadDevice::executor_type executor_type;
 
-    explicit initiate_async_read_at_buffer_sequence(
-        AsyncRandomAccessReadDevice& device)
+    explicit initiate_async_read_at(AsyncRandomAccessReadDevice& device)
       : device_(device)
     {
     }
@@ -386,7 +384,7 @@ namespace detail
 
       non_const_lvalue<ReadHandler> handler2(handler);
       non_const_lvalue<CompletionCondition> completion_cond2(completion_cond);
-      start_read_at_buffer_sequence_op(device_, offset, buffers,
+      start_read_at_op(device_, offset, buffers,
           asio::buffer_sequence_begin(buffers),
           completion_cond2.value, handler2.value);
     }
@@ -423,36 +421,45 @@ struct associator<Associator,
 template <typename AsyncRandomAccessReadDevice,
     typename MutableBufferSequence, typename CompletionCondition,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadHandler>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
     void (asio::error_code, std::size_t))
 async_read_at(AsyncRandomAccessReadDevice& d,
     uint64_t offset, const MutableBufferSequence& buffers,
     CompletionCondition completion_condition,
-    ASIO_MOVE_ARG(ReadHandler) handler)
+    ASIO_MOVE_ARG(ReadToken) token)
+  ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<ReadToken,
+      void (asio::error_code, std::size_t)>(
+        declval<detail::initiate_async_read_at<AsyncRandomAccessReadDevice> >(),
+        token, offset, buffers,
+        ASIO_MOVE_CAST(CompletionCondition)(completion_condition))))
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_at_buffer_sequence<
-        AsyncRandomAccessReadDevice>(d),
-      handler, offset, buffers,
+      detail::initiate_async_read_at<AsyncRandomAccessReadDevice>(d),
+      token, offset, buffers,
       ASIO_MOVE_CAST(CompletionCondition)(completion_condition));
 }
 
 template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadHandler>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
     void (asio::error_code, std::size_t))
 async_read_at(AsyncRandomAccessReadDevice& d,
     uint64_t offset, const MutableBufferSequence& buffers,
-    ASIO_MOVE_ARG(ReadHandler) handler)
+    ASIO_MOVE_ARG(ReadToken) token)
+  ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<ReadToken,
+      void (asio::error_code, std::size_t)>(
+        declval<detail::initiate_async_read_at<AsyncRandomAccessReadDevice> >(),
+        token, offset, buffers, transfer_all())))
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_at_buffer_sequence<
-        AsyncRandomAccessReadDevice>(d),
-      handler, offset, buffers, transfer_all());
+      detail::initiate_async_read_at<AsyncRandomAccessReadDevice>(d),
+      token, offset, buffers, transfer_all());
 }
 
 #if !defined(ASIO_NO_EXTENSIONS)
@@ -693,34 +700,47 @@ struct associator<Associator,
 template <typename AsyncRandomAccessReadDevice,
     typename Allocator, typename CompletionCondition,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadHandler>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
     void (asio::error_code, std::size_t))
 async_read_at(AsyncRandomAccessReadDevice& d,
     uint64_t offset, asio::basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition,
-    ASIO_MOVE_ARG(ReadHandler) handler)
+    ASIO_MOVE_ARG(ReadToken) token)
+  ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<ReadToken,
+      void (asio::error_code, std::size_t)>(
+        declval<detail::initiate_async_read_at_streambuf<
+          AsyncRandomAccessReadDevice> >(),
+        token, offset, &b,
+        ASIO_MOVE_CAST(CompletionCondition)(completion_condition))))
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (asio::error_code, std::size_t)>(
       detail::initiate_async_read_at_streambuf<AsyncRandomAccessReadDevice>(d),
-      handler, offset, &b,
+      token, offset, &b,
       ASIO_MOVE_CAST(CompletionCondition)(completion_condition));
 }
 
 template <typename AsyncRandomAccessReadDevice, typename Allocator,
     ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadHandler>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+      std::size_t)) ReadToken>
+inline ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadToken,
     void (asio::error_code, std::size_t))
 async_read_at(AsyncRandomAccessReadDevice& d,
     uint64_t offset, asio::basic_streambuf<Allocator>& b,
-    ASIO_MOVE_ARG(ReadHandler) handler)
+    ASIO_MOVE_ARG(ReadToken) token)
+  ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<ReadToken,
+      void (asio::error_code, std::size_t)>(
+        declval<detail::initiate_async_read_at_streambuf<
+          AsyncRandomAccessReadDevice> >(),
+        token, offset, &b, transfer_all())))
 {
-  return async_initiate<ReadHandler,
+  return async_initiate<ReadToken,
     void (asio::error_code, std::size_t)>(
       detail::initiate_async_read_at_streambuf<AsyncRandomAccessReadDevice>(d),
-      handler, offset, &b, transfer_all());
+      token, offset, &b, transfer_all());
 }
 
 #endif // !defined(ASIO_NO_IOSTREAM)