couchbase 3.5.3 → 3.5.4

data/ext/cache/asio/{6a3b5a552ffb18a235024ec851619cfcb1337a98 → b710bc0ca14b231d20e983b02d27485125c7860e}/asio/asio/include/asio/experimental/detail/channel_service.hpp

@@ -18,10 +18,12 @@
 #include "asio/detail/config.hpp"
 #include "asio/associated_cancellation_slot.hpp"
 #include "asio/cancellation_type.hpp"
+#include "asio/detail/completion_message.hpp"
+#include "asio/detail/completion_payload.hpp"
+#include "asio/detail/completion_payload_handler.hpp"
 #include "asio/detail/mutex.hpp"
 #include "asio/detail/op_queue.hpp"
 #include "asio/execution_context.hpp"
-#include "asio/experimental/detail/channel_message.hpp"
 #include "asio/experimental/detail/channel_receive_op.hpp"
 #include "asio/experimental/detail/channel_send_op.hpp"
 #include "asio/experimental/detail/has_signature.hpp"
@@ -231,7 +233,7 @@ private:
     void operator()(Args&&... args)
     {
       op_->post(
-          channel_message<Signature>(0,
+          asio::detail::completion_message<Signature>(0,
             static_cast<Args&&>(args)...));
     }
 
@@ -307,8 +309,8 @@ struct channel_service<Mutex>::implementation_type : base_implementation_type
           typename traits_type::receive_closed_signature,
           Signatures...
         >::value,
-        channel_payload<Signatures...>,
-        channel_payload<
+        asio::detail::completion_payload<Signatures...>,
+        asio::detail::completion_payload<
           Signatures...,
           typename traits_type::receive_closed_signature
         >
@@ -319,11 +321,11 @@ struct channel_service<Mutex>::implementation_type : base_implementation_type
           Signatures...,
           typename traits_type::receive_cancelled_signature
         >::value,
-        channel_payload<
+        asio::detail::completion_payload<
           Signatures...,
           typename traits_type::receive_cancelled_signature
         >,
-        channel_payload<
+        asio::detail::completion_payload<
           Signatures...,
           typename traits_type::receive_cancelled_signature,
           typename traits_type::receive_closed_signature
@@ -404,8 +406,8 @@ struct channel_service<Mutex>::implementation_type<Traits, R()>
           typename traits_type::receive_closed_signature,
           R()
         >::value,
-        channel_payload<R()>,
-        channel_payload<
+        asio::detail::completion_payload<R()>,
+        asio::detail::completion_payload<
           R(),
           typename traits_type::receive_closed_signature
         >
@@ -416,11 +418,11 @@ struct channel_service<Mutex>::implementation_type<Traits, R()>
           R(),
           typename traits_type::receive_cancelled_signature
         >::value,
-        channel_payload<
+        asio::detail::completion_payload<
           R(),
           typename traits_type::receive_cancelled_signature
         >,
-        channel_payload<
+        asio::detail::completion_payload<
           R(),
           typename traits_type::receive_cancelled_signature,
           typename traits_type::receive_closed_signature
@@ -465,7 +467,7 @@ struct channel_service<Mutex>::implementation_type<Traits, R()>
   // Get the element at the front of the buffer.
   payload_type buffer_front()
   {
-    return payload_type(channel_message<R()>(0));
+    return payload_type(asio::detail::completion_message<R()>(0));
   }
 
   // Pop a value from the front of the buffer.
@@ -507,8 +509,8 @@ struct channel_service<Mutex>::implementation_type<
           typename traits_type::receive_closed_signature,
           R(asio::error_code)
         >::value,
-        channel_payload<R(asio::error_code)>,
-        channel_payload<
+        asio::detail::completion_payload<R(asio::error_code)>,
+        asio::detail::completion_payload<
           R(asio::error_code),
           typename traits_type::receive_closed_signature
         >
@@ -519,11 +521,11 @@ struct channel_service<Mutex>::implementation_type<
           R(asio::error_code),
           typename traits_type::receive_cancelled_signature
         >::value,
-        channel_payload<
+        asio::detail::completion_payload<
           R(asio::error_code),
           typename traits_type::receive_cancelled_signature
         >,
-        channel_payload<
+        asio::detail::completion_payload<
           R(asio::error_code),
           typename traits_type::receive_cancelled_signature,
           typename traits_type::receive_closed_signature

data/ext/cache/asio/{6a3b5a552ffb18a235024ec851619cfcb1337a98 → b710bc0ca14b231d20e983b02d27485125c7860e}/asio/asio/include/asio/experimental/detail/coro_promise_allocator.hpp

@@ -64,7 +64,6 @@ constexpr std::size_t variadic_first(std::size_t = 0u)
   return std::numeric_limits<std::size_t>::max();
 }
 
-
 template <typename T, typename First, typename... Args>
 constexpr std::size_t variadic_first(std::size_t pos = 0u)
 {
@@ -94,14 +93,14 @@ struct coro_promise_allocator
   allocator_type get_allocator() const {return alloc_;}
 
   template <typename... Args>
-  void* operator new(const std::size_t size, Args & ... args)
+  void* operator new(std::size_t size, Args & ... args)
   {
     return allocate_coroutine(size,
         get_variadic<variadic_first<std::allocator_arg_t,
           std::decay_t<Args>...>() + 1u>(args...));
   }
 
-  void operator delete(void* raw, const std::size_t size)
+  void operator delete(void* raw, std::size_t size)
   {
     deallocate_coroutine<allocator_type>(raw, size);
   }

data/ext/cache/asio/{6a3b5a552ffb18a235024ec851619cfcb1337a98 → b710bc0ca14b231d20e983b02d27485125c7860e}/asio/asio/include/asio/experimental/detail/impl/channel_service.hpp

@@ -517,7 +517,8 @@ bool channel_service<Mutex>::try_receive(
       }
       lock.unlock();
       asio::detail::non_const_lvalue<Handler> handler2(handler);
-      channel_handler<payload_type, decay_t<Handler>>(
+      asio::detail::completion_payload_handler<
+        payload_type, decay_t<Handler>>(
           static_cast<payload_type&&>(payload), handler2.value)();
       return true;
     }
@@ -532,7 +533,8 @@ bool channel_service<Mutex>::try_receive(
       send_op->post();
       lock.unlock();
       asio::detail::non_const_lvalue<Handler> handler2(handler);
-      channel_handler<payload_type, decay_t<Handler>>(
+      asio::detail::completion_payload_handler<
+        payload_type, decay_t<Handler>>(
           static_cast<payload_type&&>(payload), handler2.value)();
       return true;
     }

data/ext/cache/asio/{6a3b5a552ffb18a235024ec851619cfcb1337a98 → b710bc0ca14b231d20e983b02d27485125c7860e}/asio/asio/include/asio/experimental/detail/partial_promise.hpp

@@ -54,12 +54,12 @@ template <typename Allocator>
 struct partial_promise_base
 {
   template <typename Executor, typename Token, typename... Args>
-  void* operator new(const std::size_t size, Executor&, Token& tk, Args&...)
+  void* operator new(std::size_t size, Executor&, Token& tk, Args&...)
   {
     return allocate_coroutine<Allocator>(size, get_associated_allocator(tk));
   }
 
-  void operator delete(void* raw, const std::size_t size)
+  void operator delete(void* raw, std::size_t size)
   {
     deallocate_coroutine<Allocator>(raw, size);
   }
@@ -110,9 +110,7 @@ struct partial_promise : partial_promise_base<Allocator>
   }
 };
 
-
-
-}; // namespace detail
+} // namespace detail
 } // namespace experimental
 } // namespace asio
 

data/ext/cache/asio/{6a3b5a552ffb18a235024ec851619cfcb1337a98 → b710bc0ca14b231d20e983b02d27485125c7860e}/asio/asio/include/asio/experimental/impl/as_single.hpp

@@ -20,6 +20,7 @@
 #include "asio/associator.hpp"
 #include "asio/async_result.hpp"
 #include "asio/detail/handler_cont_helpers.hpp"
+#include "asio/detail/initiation_base.hpp"
 #include "asio/detail/type_traits.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -110,23 +111,27 @@ template <typename CompletionToken, typename Signature>
 struct async_result<experimental::as_single_t<CompletionToken>, Signature>
 {
   template <typename Initiation>
-  struct init_wrapper
+  struct init_wrapper : detail::initiation_base<Initiation>
   {
-    init_wrapper(Initiation init)
-      : initiation_(static_cast<Initiation&&>(init))
+    using detail::initiation_base<Initiation>::initiation_base;
+
+    template <typename Handler, typename... Args>
+    void operator()(Handler&& handler, Args&&... args) &&
     {
+      static_cast<Initiation&&>(*this)(
+          experimental::detail::as_single_handler<decay_t<Handler>>(
+            static_cast<Handler&&>(handler)),
+          static_cast<Args&&>(args)...);
     }
 
     template <typename Handler, typename... Args>
-    void operator()(Handler&& handler, Args&&... args)
+    void operator()(Handler&& handler, Args&&... args) const &
     {
-      static_cast<Initiation&&>(initiation_)(
+      static_cast<const Initiation&>(*this)(
           experimental::detail::as_single_handler<decay_t<Handler>>(
             static_cast<Handler&&>(handler)),
           static_cast<Args&&>(args)...);
     }
-
-    Initiation initiation_;
   };
 
   template <typename Initiation, typename RawCompletionToken, typename... Args>

data/ext/cache/asio/{6a3b5a552ffb18a235024ec851619cfcb1337a98 → b710bc0ca14b231d20e983b02d27485125c7860e}/asio/asio/include/asio/experimental/parallel_group.hpp

@@ -207,6 +207,36 @@ public:
 /**
  * For example:
  * @code asio::experimental::make_parallel_group(
+ *    in.async_read_some(asio::buffer(data)),
+ *    timer.async_wait()
+ *  ).async_wait(
+ *    asio::experimental::wait_for_all(),
+ *    [](
+ *        std::array<std::size_t, 2> completion_order,
+ *        std::error_code ec1, std::size_t n1,
+ *        std::error_code ec2
+ *    )
+ *    {
+ *      switch (completion_order[0])
+ *      {
+ *      case 0:
+ *        {
+ *          std::cout << "descriptor finished: " << ec1 << ", " << n1 << "\n";
+ *        }
+ *        break;
+ *      case 1:
+ *        {
+ *          std::cout << "timer finished: " << ec2 << "\n";
+ *        }
+ *        break;
+ *      }
+ *    }
+ *  );
+ * @endcode
+ *
+ * If preferred, the asynchronous operations may be explicitly packaged as
+ * function objects:
+ * @code asio::experimental::make_parallel_group(
  *    [&](auto token)
  *    {
  *      return in.async_read_some(asio::buffer(data), token);
@@ -332,28 +362,12 @@ public:
  *
  * For example:
  * @code
- * using op_type = decltype(
- *     socket1.async_read_some(
- *       asio::buffer(data1),
- *       asio::deferred
- *     )
- *   );
+ * using op_type =
+ *   decltype(socket1.async_read_some(asio::buffer(data1)));
  *
  * std::vector<op_type> ops;
- *
- * ops.push_back(
- *     socket1.async_read_some(
- *       asio::buffer(data1),
- *       asio::deferred
- *     )
- *   );
- *
- * ops.push_back(
- *     socket2.async_read_some(
- *       asio::buffer(data2),
- *       asio::deferred
- *     )
- *   );
+ * ops.push_back(socket1.async_read_some(asio::buffer(data1)));
+ * ops.push_back(socket2.async_read_some(asio::buffer(data2)));
  *
  * asio::experimental::make_parallel_group(ops).async_wait(
  *     asio::experimental::wait_for_all(),
@@ -391,28 +405,12 @@ make_parallel_group(Range&& range,
  *
  * For example:
  * @code
- * using op_type = decltype(
- *     socket1.async_read_some(
- *       asio::buffer(data1),
- *       asio::deferred
- *     )
- *   );
+ * using op_type =
+ *   decltype(socket1.async_read_some(asio::buffer(data1)));
  *
  * std::vector<op_type> ops;
- *
- * ops.push_back(
- *     socket1.async_read_some(
- *       asio::buffer(data1),
- *       asio::deferred
- *     )
- *   );
- *
- * ops.push_back(
- *     socket2.async_read_some(
- *       asio::buffer(data2),
- *       asio::deferred
- *     )
- *   );
+ * ops.push_back(socket1.async_read_some(asio::buffer(data1)));
+ * ops.push_back(socket2.async_read_some(asio::buffer(data2)));
  *
  * asio::experimental::make_parallel_group(
  *     std::allocator_arg_t,

data/ext/cache/asio/{6a3b5a552ffb18a235024ec851619cfcb1337a98 → b710bc0ca14b231d20e983b02d27485125c7860e}/asio/asio/include/asio/experimental/promise.hpp

@@ -84,8 +84,9 @@ struct promise_value_type<>
  * awaitable<void> read_write_some(asio::ip::tcp::socket & sock,
  *     asio::mutable_buffer read_buf, asio::const_buffer to_write)
  * {
- *   auto p = asio::async_read(read_buf, asio::use_awaitable);
- *   co_await asio::async_write_some(to_write, asio::deferred);
+ *   auto p = asio::async_read(read_buf,
+ *       asio::experimental::use_promise);
+ *   co_await asio::async_write_some(to_write);
  *   co_await p;
  * }
  * @endcode
@@ -139,7 +140,6 @@ struct promise<void(Ts...), Executor,  Allocator>
    */
   ~promise() { cancel(); }
 
-
 private:
 #if !defined(GENERATING_DOCUMENTATION)
   template <typename, typename, typename> friend struct promise;

data/ext/cache/asio/{6a3b5a552ffb18a235024ec851619cfcb1337a98 → b710bc0ca14b231d20e983b02d27485125c7860e}/asio/asio/include/asio/experimental/use_coro.hpp

@@ -47,8 +47,9 @@ namespace experimental {
  * the asynchronous operation completes, and the result of the operation is
  * returned.
  *
- * Note that this token is not the most efficient (use @c asio::deferred
- * for that) but does provide type erasure, as it will always return a @c coro.
+ * Note that this token is not the most efficient (use the default completion
+ * token @c asio::deferred for that) but does provide type erasure, as it
+ * will always return a @c coro.
  */
 template <typename Allocator = std::allocator<void>>
 struct use_coro_t
@@ -83,7 +84,6 @@ struct use_coro_t
   {
   }
 
-
   /// Specify an alternate allocator.
   template <typename OtherAllocator>
   use_coro_t<OtherAllocator> rebind(const OtherAllocator& allocator) const

data/ext/cache/asio/b710bc0ca14b231d20e983b02d27485125c7860e/asio/asio/include/asio/immediate.hpp

@@ -0,0 +1,142 @@
+//
+// immediate.hpp
+// ~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2024 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_IMMEDIATE_HPP
+#define ASIO_IMMEDIATE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include "asio/associated_immediate_executor.hpp"
+#include "asio/async_result.hpp"
+#include "asio/dispatch.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace detail {
+
+template <typename Executor>
+class initiate_immediate
+{
+public:
+  typedef Executor executor_type;
+
+  explicit initiate_immediate(const Executor& ex)
+    : ex_(ex)
+  {
+  }
+
+  executor_type get_executor() const noexcept
+  {
+    return ex_;
+  }
+
+  template <typename CompletionHandler>
+  void operator()(CompletionHandler&& handler) const
+  {
+    typename associated_immediate_executor<
+      CompletionHandler, executor_type>::type ex =
+        (get_associated_immediate_executor)(handler, ex_);
+    (dispatch)(ex, static_cast<CompletionHandler&&>(handler));
+  }
+
+private:
+  Executor ex_;
+};
+
+} // namespace detail
+
+/// Launch a trivial asynchronous operation that completes immediately.
+/**
+ * The async_immediate function is intended for use by composed operations,
+ * which can delegate to this operation in order to implement the correct
+ * semantics for immediate completion.
+ *
+ * @param ex The asynchronous operation's I/O executor.
+ *
+ * @param token The completion token.
+ *
+ * The completion handler is immediately submitted for execution by calling
+ * asio::dispatch() on the handler's associated immediate executor.
+ *
+ * If the completion handler does not have a customised associated immediate
+ * executor, then the handler is submitted as if by calling asio::post()
+ * on the supplied I/O executor.
+ *
+ * @par Completion Signature
+ * @code void() @endcode
+ */
+template <typename Executor,
+    ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken
+      = default_completion_token_t<Executor>>
+inline auto async_immediate(const Executor& ex,
+    NullaryToken&& token = default_completion_token_t<Executor>(),
+    constraint_t<
+      (execution::is_executor<Executor>::value
+          && can_require<Executor, execution::blocking_t::never_t>::value)
+        || is_executor<Executor>::value
+    > = 0)
+  -> decltype(
+    async_initiate<NullaryToken, void()>(
+      declval<detail::initiate_immediate<Executor>>(), token))
+{
+  return async_initiate<NullaryToken, void()>(
+      detail::initiate_immediate<Executor>(ex), token);
+}
+
+/// Launch a trivial asynchronous operation that completes immediately.
+/**
+ * The async_immediate function is intended for use by composed operations,
+ * which can delegate to this operation in order to implement the correct
+ * semantics for immediate completion.
+ *
+ * @param ex The execution context used to obtain the asynchronous operation's
+ * I/O executor.
+ *
+ * @param token The completion token.
+ *
+ * The completion handler is immediately submitted for execution by calling
+ * asio::dispatch() on the handler's associated immediate executor.
+ *
+ * If the completion handler does not have a customised associated immediate
+ * executor, then the handler is submitted as if by calling asio::post()
+ * on the I/O executor obtained from the supplied execution context.
+ *
+ * @par Completion Signature
+ * @code void() @endcode
+ */
+template <typename ExecutionContext,
+    ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken
+      = default_completion_token_t<typename ExecutionContext::executor_type>>
+inline auto async_immediate(ExecutionContext& ctx,
+    NullaryToken&& token = default_completion_token_t<
+      typename ExecutionContext::executor_type>(),
+    constraint_t<
+      is_convertible<ExecutionContext&, execution_context&>::value
+    > = 0)
+  -> decltype(
+    async_initiate<NullaryToken, void()>(
+      declval<detail::initiate_immediate<
+        typename ExecutionContext::executor_type>>(), token))
+{
+  return async_initiate<NullaryToken, void()>(
+      detail::initiate_immediate<
+        typename ExecutionContext::executor_type>(
+          ctx.get_executor()), token);
+}
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IMMEDIATE_HPP

data/ext/cache/asio/{6a3b5a552ffb18a235024ec851619cfcb1337a98 → b710bc0ca14b231d20e983b02d27485125c7860e}/asio/asio/include/asio/impl/append.hpp

@@ -19,6 +19,7 @@
 #include "asio/associator.hpp"
 #include "asio/async_result.hpp"
 #include "asio/detail/handler_cont_helpers.hpp"
+#include "asio/detail/initiation_base.hpp"
 #include "asio/detail/type_traits.hpp"
 #include "asio/detail/utility.hpp"
 
@@ -93,25 +94,31 @@ struct async_result<append_t<CompletionToken, Values...>, Signature>
       Signature, Values...>::type signature;
 
   template <typename Initiation>
-  struct init_wrapper
+  struct init_wrapper : detail::initiation_base<Initiation>
   {
-    init_wrapper(Initiation init)
-      : initiation_(static_cast<Initiation&&>(init))
+    using detail::initiation_base<Initiation>::initiation_base;
+
+    template <typename Handler, typename... Args>
+    void operator()(Handler&& handler,
+        std::tuple<Values...> values, Args&&... args) &&
     {
+      static_cast<Initiation&&>(*this)(
+          detail::append_handler<decay_t<Handler>, Values...>(
+            static_cast<Handler&&>(handler),
+            static_cast<std::tuple<Values...>&&>(values)),
+          static_cast<Args&&>(args)...);
     }
 
     template <typename Handler, typename... Args>
     void operator()(Handler&& handler,
-        std::tuple<Values...> values, Args&&... args)
+        std::tuple<Values...> values, Args&&... args) const &
     {
-      static_cast<Initiation&&>(initiation_)(
+      static_cast<const Initiation&>(*this)(
           detail::append_handler<decay_t<Handler>, Values...>(
             static_cast<Handler&&>(handler),
             static_cast<std::tuple<Values...>&&>(values)),
           static_cast<Args&&>(args)...);
     }
-
-    Initiation initiation_;
   };
 
   template <typename Initiation, typename RawCompletionToken, typename... Args>

data/ext/cache/asio/{6a3b5a552ffb18a235024ec851619cfcb1337a98 → b710bc0ca14b231d20e983b02d27485125c7860e}/asio/asio/include/asio/impl/as_tuple.hpp

@@ -17,9 +17,11 @@
 
 #include "asio/detail/config.hpp"
 #include <tuple>
+#include "asio/associated_executor.hpp"
 #include "asio/associator.hpp"
 #include "asio/async_result.hpp"
 #include "asio/detail/handler_cont_helpers.hpp"
+#include "asio/detail/initiation_base.hpp"
 #include "asio/detail/type_traits.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -118,23 +120,27 @@ struct async_result<as_tuple_t<CompletionToken>, Signatures...>
       typename detail::as_tuple_signature<Signatures>::type...>
 {
   template <typename Initiation>
-  struct init_wrapper
+  struct init_wrapper : detail::initiation_base<Initiation>
   {
-    init_wrapper(Initiation init)
-      : initiation_(static_cast<Initiation&&>(init))
+    using detail::initiation_base<Initiation>::initiation_base;
+
+    template <typename Handler, typename... Args>
+    void operator()(Handler&& handler, Args&&... args) &&
     {
+      static_cast<Initiation&&>(*this)(
+          detail::as_tuple_handler<decay_t<Handler>>(
+            static_cast<Handler&&>(handler)),
+          static_cast<Args&&>(args)...);
     }
 
     template <typename Handler, typename... Args>
-    void operator()(Handler&& handler, Args&&... args)
+    void operator()(Handler&& handler, Args&&... args) const &
     {
-      static_cast<Initiation&&>(initiation_)(
+      static_cast<const Initiation&>(*this)(
           detail::as_tuple_handler<decay_t<Handler>>(
             static_cast<Handler&&>(handler)),
           static_cast<Args&&>(args)...);
     }
-
-    Initiation initiation_;
   };
 
   template <typename Initiation, typename RawCompletionToken, typename... Args>
@@ -171,23 +177,27 @@ struct async_result<as_tuple_t<CompletionToken>, Signature>
       typename detail::as_tuple_signature<Signature>::type>
 {
   template <typename Initiation>
-  struct init_wrapper
+  struct init_wrapper : detail::initiation_base<Initiation>
   {
-    init_wrapper(Initiation init)
-      : initiation_(static_cast<Initiation&&>(init))
+    using detail::initiation_base<Initiation>::initiation_base;
+
+    template <typename Handler, typename... Args>
+    void operator()(Handler&& handler, Args&&... args) &&
     {
+      static_cast<Initiation&&>(*this)(
+          detail::as_tuple_handler<decay_t<Handler>>(
+            static_cast<Handler&&>(handler)),
+          static_cast<Args&&>(args)...);
     }
 
     template <typename Handler, typename... Args>
-    void operator()(Handler&& handler, Args&&... args)
+    void operator()(Handler&& handler, Args&&... args) const &
     {
-      static_cast<Initiation&&>(initiation_)(
+      static_cast<const Initiation&>(*this)(
           detail::as_tuple_handler<decay_t<Handler>>(
             static_cast<Handler&&>(handler)),
           static_cast<Args&&>(args)...);
     }
-
-    Initiation initiation_;
   };
 
   template <typename Initiation, typename RawCompletionToken, typename... Args>
@@ -236,6 +246,27 @@ struct associator<Associator,
   }
 };
 
+template <typename... Signatures>
+struct async_result<partial_as_tuple, Signatures...>
+{
+  template <typename Initiation, typename RawCompletionToken, typename... Args>
+  static auto initiate(Initiation&& initiation,
+      RawCompletionToken&&, Args&&... args)
+    -> decltype(
+      async_initiate<Signatures...>(
+        static_cast<Initiation&&>(initiation),
+        as_tuple_t<
+          default_completion_token_t<associated_executor_t<Initiation>>>{},
+        static_cast<Args&&>(args)...))
+  {
+    return async_initiate<Signatures...>(
+        static_cast<Initiation&&>(initiation),
+        as_tuple_t<
+          default_completion_token_t<associated_executor_t<Initiation>>>{},
+        static_cast<Args&&>(args)...);
+  }
+};
+
 #endif // !defined(GENERATING_DOCUMENTATION)
 
 } // namespace asio