couchbase 4.4.1 → 4.4.2

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

@@ -1,6 +1,6 @@
 //
-// compose.hpp
-// ~~~~~~~~~~~
+// composed.hpp
+// ~~~~~~~~~~~~
 //
 // Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
@@ -8,8 +8,8 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#ifndef ASIO_COMPOSE_HPP
-#define ASIO_COMPOSE_HPP
+#ifndef ASIO_COMPOSED_HPP
+#define ASIO_COMPOSED_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
@@ -28,12 +28,12 @@
 namespace asio {
 namespace detail {
 
-template <typename Impl, typename Work, typename Handler, typename Signature>
+template <typename Impl, typename Work,
+    typename Handler, typename... Signatures>
 class composed_op;
 
-template <typename Impl, typename Work, typename Handler,
-    typename R, typename... Args>
-class composed_op<Impl, Work, Handler, R(Args...)>
+template <typename Impl, typename Work, typename Handler>
+class composed_op<Impl, Work, Handler>
   : public base_from_cancellation_state<Handler>
 {
 public:
@@ -82,7 +82,7 @@ public:
     return (get_associated_allocator)(handler_, std::allocator<void>());
   }
 
-  template<typename... T>
+  template <typename... T>
   void operator()(T&&... t)
   {
     if (invocations_ < ~0u)
@@ -91,10 +91,11 @@ public:
     impl_(*this, static_cast<T&&>(t)...);
   }
 
-  void complete(Args... args)
+  template <typename... Args>
+  auto complete(Args&&... args)
+    -> decltype(declval<Handler>()(static_cast<Args&&>(args)...))
   {
-    this->work_.reset();
-    static_cast<Handler&&>(this->handler_)(static_cast<Args&&>(args)...);
+    return static_cast<Handler&&>(this->handler_)(static_cast<Args&&>(args)...);
   }
 
   void reset_cancellation_state()
@@ -130,6 +131,56 @@ public:
   unsigned invocations_;
 };
 
+template <typename Impl, typename Work, typename Handler,
+    typename R, typename... Args>
+class composed_op<Impl, Work, Handler, R(Args...)>
+  : public composed_op<Impl, Work, Handler>
+{
+public:
+  using composed_op<Impl, Work, Handler>::composed_op;
+
+  template <typename... T>
+  void operator()(T&&... t)
+  {
+    if (this->invocations_ < ~0u)
+      ++this->invocations_;
+    this->get_cancellation_state().slot().clear();
+    this->impl_(*this, static_cast<T&&>(t)...);
+  }
+
+  void complete(Args... args)
+  {
+    this->work_.reset();
+    static_cast<Handler&&>(this->handler_)(static_cast<Args&&>(args)...);
+  }
+};
+
+template <typename Impl, typename Work, typename Handler,
+    typename R, typename... Args, typename... Signatures>
+class composed_op<Impl, Work, Handler, R(Args...), Signatures...>
+  : public composed_op<Impl, Work, Handler, Signatures...>
+{
+public:
+  using composed_op<Impl, Work, Handler, Signatures...>::composed_op;
+
+  template <typename... T>
+  void operator()(T&&... t)
+  {
+    if (this->invocations_ < ~0u)
+      ++this->invocations_;
+    this->get_cancellation_state().slot().clear();
+    this->impl_(*this, static_cast<T&&>(t)...);
+  }
+
+  using composed_op<Impl, Work, Handler, Signatures...>::complete;
+
+  void complete(Args... args)
+  {
+    this->work_.reset();
+    static_cast<Handler&&>(this->handler_)(static_cast<Args&&>(args)...);
+  }
+};
+
 template <typename Impl, typename Work, typename Handler, typename Signature>
 inline bool asio_handler_is_continuation(
     composed_op<Impl, Work, Handler, Signature>* this_handler)
@@ -139,15 +190,16 @@ inline bool asio_handler_is_continuation(
         this_handler->handler_);
 }
 
-template <typename Signature, typename Executors>
-class initiate_composed_op
+template <typename Implementation, typename Executors, typename... Signatures>
+class initiate_composed
 {
 public:
   typedef typename composed_io_executors<Executors>::head_type executor_type;
 
-  template <typename T>
-  explicit initiate_composed_op(int, T&& executors)
-    : executors_(static_cast<T&&>(executors))
+  template <typename I>
+  initiate_composed(I&& impl, composed_io_executors<Executors>&& executors)
+    : implementation_(std::forward<I>(impl)),
+      executors_(std::move(executors))
   {
   }
 
@@ -156,26 +208,70 @@ public:
     return executors_.head_;
   }
 
-  template <typename Handler, typename Impl>
-  void operator()(Handler&& handler,
-      Impl&& impl) const
+  template <typename Handler, typename... Args>
+  void operator()(Handler&& handler, Args&&... args) const &
+  {
+    composed_op<decay_t<Implementation>, composed_work<Executors>,
+      decay_t<Handler>, Signatures...>(implementation_,
+        composed_work<Executors>(executors_),
+        static_cast<Handler&&>(handler))(static_cast<Args&&>(args)...);
+  }
+
+  template <typename Handler, typename... Args>
+  void operator()(Handler&& handler, Args&&... args) &&
   {
-    composed_op<decay_t<Impl>, composed_work<Executors>,
-      decay_t<Handler>, Signature>(
-        static_cast<Impl&&>(impl),
+    composed_op<decay_t<Implementation>, composed_work<Executors>,
+      decay_t<Handler>, Signatures...>(
+        static_cast<Implementation&&>(implementation_),
         composed_work<Executors>(executors_),
-        static_cast<Handler&&>(handler))();
+        static_cast<Handler&&>(handler))(static_cast<Args&&>(args)...);
   }
 
 private:
+  Implementation implementation_;
   composed_io_executors<Executors> executors_;
 };
 
-template <typename Signature, typename Executors>
-inline initiate_composed_op<Signature, Executors> make_initiate_composed_op(
+template <typename Implementation, typename... Signatures>
+class initiate_composed<Implementation, void(), Signatures...>
+{
+public:
+  template <typename I>
+  initiate_composed(I&& impl, composed_io_executors<void()>&&)
+    : implementation_(std::forward<I>(impl))
+  {
+  }
+
+  template <typename Handler, typename... Args>
+  void operator()(Handler&& handler, Args&&... args) const &
+  {
+    composed_op<decay_t<Implementation>, composed_work<void()>,
+      decay_t<Handler>, Signatures...>(implementation_,
+        composed_work<void()>(composed_io_executors<void()>()),
+        static_cast<Handler&&>(handler))(static_cast<Args&&>(args)...);
+  }
+
+  template <typename Handler, typename... Args>
+  void operator()(Handler&& handler, Args&&... args) &&
+  {
+    composed_op<decay_t<Implementation>, composed_work<void()>,
+      decay_t<Handler>, Signatures...>(
+        static_cast<Implementation&&>(implementation_),
+        composed_work<void()>(composed_io_executors<void()>()),
+        static_cast<Handler&&>(handler))(static_cast<Args&&>(args)...);
+  }
+
+private:
+  Implementation implementation_;
+};
+
+template <typename... Signatures, typename Implementation, typename Executors>
+inline initiate_composed<Implementation, Executors, Signatures...>
+make_initiate_composed(Implementation&& implementation,
     composed_io_executors<Executors>&& executors)
 {
-  return initiate_composed_op<Signature, Executors>(0,
+  return initiate_composed<decay_t<Implementation>, Executors, Signatures...>(
+      static_cast<Implementation&&>(implementation),
       static_cast<composed_io_executors<Executors>&&>(executors));
 }
 
@@ -207,11 +303,12 @@ struct associator<Associator,
 
 #endif // !defined(GENERATING_DOCUMENTATION)
 
-/// Launch an asynchronous operation with a stateful implementation.
+/// Creates an initiation function object that may be used to launch an
+/// asynchronous operation with a stateful implementation.
 /**
- * The async_compose function simplifies the implementation of composed
- * asynchronous operations automatically wrapping a stateful function object
- * with a conforming intermediate completion handler.
+ * The @c composed function simplifies the implementation of composed
+ * asynchronous operations automatically by wrapping a stateful function object
+ * for use as an initiation function object.
  *
  * @param implementation A function object that contains the implementation of
  * the composed asynchronous operation. The first argument to the function
@@ -220,17 +317,14 @@ struct associator<Associator,
  * completion handlers of any asynchronous operations performed by the
  * implementation.
  *
- * @param token The completion token.
- *
  * @param io_objects_or_executors Zero or more I/O objects or I/O executors for
  * which outstanding work must be maintained.
  *
  * @par Per-Operation Cancellation
- * By default, terminal per-operation cancellation is enabled for
- * composed operations that are implemented using @c async_compose. To
- * disable cancellation for the composed operation, or to alter its
- * supported cancellation types, call the @c self object's @c
- * reset_cancellation_state function.
+ * By default, terminal per-operation cancellation is enabled for composed
+ * operations that are implemented using @c composed. To disable cancellation
+ * for the composed operation, or to alter its supported cancellation types,
+ * call the @c self object's @c reset_cancellation_state function.
  *
  * @par Example:
  *
@@ -242,8 +336,8 @@ struct associator<Associator,
  *
  *   template <typename Self>
  *   void operator()(Self& self,
- *       asio::error_code error = {},
- *       std::size_t n = 0)
+ *       asio::error_code error,
+ *       std::size_t n)
  *   {
  *     switch (state_)
  *     {
@@ -275,41 +369,41 @@ struct associator<Associator,
  * template <typename CompletionToken>
  * auto async_echo(tcp::socket& socket,
  *     asio::mutable_buffer buffer,
- *     CompletionToken&& token) ->
- *   decltype(
- *     asio::async_compose<CompletionToken,
+ *     CompletionToken&& token)
+ *   -> decltype(
+ *     asio::async_initiate<CompletionToken,
  *       void(asio::error_code, std::size_t)>(
- *         std::declval<async_echo_implementation>(),
- *         token, socket))
+ *         asio::composed(
+ *           async_echo_implementation{socket, buffer,
+ *             async_echo_implementation::starting}, socket),
+ *         token))
  * {
- *   return asio::async_compose<CompletionToken,
+ *   return asio::async_initiate<CompletionToken,
  *     void(asio::error_code, std::size_t)>(
- *       async_echo_implementation{socket, buffer,
- *         async_echo_implementation::starting},
- *       token, socket);
+ *       asio::composed(
+ *         async_echo_implementation{socket, buffer,
+ *           async_echo_implementation::starting}, socket),
+ *       token, asio::error_code{}, 0);
  * } @endcode
  */
-template <typename CompletionToken, typename Signature,
+template <ASIO_COMPLETION_SIGNATURE... Signatures,
     typename Implementation, typename... IoObjectsOrExecutors>
-auto async_compose(Implementation&& implementation,
-    type_identity_t<CompletionToken>& token,
+inline auto composed(Implementation&& implementation,
     IoObjectsOrExecutors&&... io_objects_or_executors)
   -> decltype(
-    async_initiate<CompletionToken, Signature>(
-      detail::make_initiate_composed_op<Signature>(
-        detail::make_composed_io_executors(
-          detail::get_composed_io_executor(
-            static_cast<IoObjectsOrExecutors&&>(
-              io_objects_or_executors))...)),
-      token, static_cast<Implementation&&>(implementation)))
+    detail::make_initiate_composed<Signatures...>(
+      static_cast<Implementation&&>(implementation),
+      detail::make_composed_io_executors(
+        detail::get_composed_io_executor(
+          static_cast<IoObjectsOrExecutors&&>(
+            io_objects_or_executors))...)))
 {
-  return async_initiate<CompletionToken, Signature>(
-      detail::make_initiate_composed_op<Signature>(
-        detail::make_composed_io_executors(
-          detail::get_composed_io_executor(
-            static_cast<IoObjectsOrExecutors&&>(
-              io_objects_or_executors))...)),
-      token, static_cast<Implementation&&>(implementation));
+  return detail::make_initiate_composed<Signatures...>(
+      static_cast<Implementation&&>(implementation),
+      detail::make_composed_io_executors(
+        detail::get_composed_io_executor(
+          static_cast<IoObjectsOrExecutors&&>(
+            io_objects_or_executors))...));
 }
 
 } // namespace asio