passenger 6.0.23 → 6.0.24

data/src/cxx_supportlib/vendor-modified/boost/asio/{experimental/impl/co_composed.hpp → co_composed.hpp}

@@ -1,6 +1,6 @@
 //
-// experimental/impl/co_composed.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// co_composed.hpp
+// ~~~~~~~~~~~~~~~
 //
 // Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
@@ -8,14 +8,17 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#ifndef BOOST_ASIO_IMPL_EXPERIMENTAL_CO_COMPOSED_HPP
-#define BOOST_ASIO_IMPL_EXPERIMENTAL_CO_COMPOSED_HPP
+#ifndef BOOST_ASIO_CO_COMPOSED_HPP
+#define BOOST_ASIO_CO_COMPOSED_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_CO_AWAIT) || defined(GENERATING_DOCUMENTATION)
+
 #include <new>
 #include <tuple>
 #include <variant>
@@ -45,7 +48,6 @@
 
 namespace boost {
 namespace asio {
-namespace experimental {
 namespace detail {
 
 #if defined(BOOST_ASIO_HAS_STD_COROUTINE)
@@ -75,7 +77,7 @@ class co_composed_handler_base;
 template <typename Executors, typename Handler, typename Return>
 class co_composed_promise;
 
-template <completion_signature... Signatures>
+template <BOOST_ASIO_COMPLETION_SIGNATURE... Signatures>
 class co_composed_returns
 {
 };
@@ -91,7 +93,7 @@ struct co_composed_completion : std::tuple<T&&...>
 {
   template <typename... U>
   co_composed_completion(U&&... u) noexcept
-    : std::tuple<T&&...>(std::forward<U>(u)...)
+    : std::tuple<T&&...>(static_cast<U&&>(u)...)
   {
   }
 };
@@ -313,8 +315,8 @@ public:
         (get_associated_cancellation_slot)(
           static_cast<co_composed_state<Executors, Handler, Return>*>(
             this)->handler()),
-        std::forward<InFilter>(in_filter),
-        std::forward<OutFilter>(out_filter));
+        static_cast<InFilter&&>(in_filter),
+        static_cast<OutFilter&&>(out_filter));
   }
 
   cancellation_type_t cancelled() const noexcept
@@ -469,7 +471,7 @@ public:
   co_composed_state(composed_io_executors<Executors>&& executors,
       H&& h, co_composed_on_suspend& on_suspend)
     : work_(std::move(executors)),
-      handler_(std::forward<H>(h)),
+      handler_(static_cast<H&&>(h)),
       on_suspend_(&on_suspend)
   {
     this->reset_cancellation_state(enable_terminal_cancellation());
@@ -482,9 +484,9 @@ public:
 
   template <typename... Args>
   [[nodiscard]] co_composed_completion<Args...> complete(Args&&... args)
-    requires requires { declval<Handler>()(std::forward<Args>(args)...); }
+    requires requires { declval<Handler>()(static_cast<Args&&>(args)...); }
   {
-    return co_composed_completion<Args...>(std::forward<Args>(args)...);
+    return co_composed_completion<Args...>(static_cast<Args&&>(args)...);
   }
 
   const Handler& handler() const noexcept
@@ -593,7 +595,7 @@ public:
   template <typename... T>
   void operator()(T&&... args)
   {
-    result_type result(std::forward<T>(args)...);
+    result_type result(static_cast<T&&>(args)...);
     this->resume(&result);
   }
 
@@ -625,7 +627,7 @@ public:
   template <typename... T>
   void operator()(const boost::system::error_code& ec, T&&... args)
   {
-    result_type result(ec, args_type(std::forward<T>(args)...));
+    result_type result(ec, args_type(static_cast<T&&>(args)...));
     this->resume(&result);
   }
 
@@ -658,7 +660,7 @@ public:
   template <typename... T>
   void operator()(std::exception_ptr ex, T&&... args)
   {
-    result_type result(std::move(ex), args_type(std::forward<T>(args)...));
+    result_type result(std::move(ex), args_type(static_cast<T&&>(args)...));
     this->resume(&result);
   }
 
@@ -864,7 +866,7 @@ public:
 # endif // defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
 #endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
         )
-        : op_(std::forward<Op>(op)),
+        : op_(static_cast<Op&&>(op)),
           promise_(promise)
 #if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
 # if defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
@@ -895,7 +897,7 @@ public:
                   static_cast<awaitable*>(p)->location_.function_name()));
 # endif // defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
 #endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
-              std::forward<Op>(static_cast<awaitable*>(p)->op_)(
+              static_cast<Op&&>(static_cast<awaitable*>(p)->op_)(
                   co_composed_handler<Executors, Handler,
                     Return, completion_signature_of_t<Op>>(
                       static_cast<awaitable*>(p)->promise_));
@@ -920,7 +922,7 @@ public:
     };
 
     state_.check_for_cancellation_on_transform();
-    return awaitable{std::forward<Op>(op), *this
+    return awaitable{static_cast<Op&&>(op), *this
 #if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
 # if defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
         , location
@@ -961,7 +963,7 @@ public:
 
             Handler handler(std::move(a.promise_.state_.handler_));
             std::tuple<decay_t<Args>...> result(
-                std::move(static_cast<std::tuple<Args&&...>>(a.result_)));
+                std::move(static_cast<std::tuple<Args&&...>&>(a.result_)));
 
             co_composed_handler_base<Executors, Handler,
               Return>(std::move(composed_handler));
@@ -1014,7 +1016,7 @@ public:
 
   template <typename I>
   initiate_co_composed(I&& impl, composed_io_executors<Executors>&& executors)
-    : implementation_(std::forward<I>(impl)),
+    : implementation_(static_cast<I&&>(impl)),
       executors_(std::move(executors))
   {
   }
@@ -1032,8 +1034,8 @@ public:
     co_composed_on_suspend on_suspend{};
     implementation_(
         co_composed_state<Executors, handler_type, returns_type>(
-          executors_, std::forward<Handler>(handler), on_suspend),
-        std::forward<InitArgs>(init_args)...);
+          executors_, static_cast<Handler&&>(handler), on_suspend),
+        static_cast<InitArgs&&>(init_args)...);
     if (on_suspend.fn_)
       on_suspend.fn_(on_suspend.arg_);
   }
@@ -1046,8 +1048,8 @@ public:
     co_composed_on_suspend on_suspend{};
     std::move(implementation_)(
         co_composed_state<Executors, handler_type, returns_type>(
-          std::move(executors_), std::forward<Handler>(handler), on_suspend),
-        std::forward<InitArgs>(init_args)...);
+          std::move(executors_), static_cast<Handler&&>(handler), on_suspend),
+        static_cast<InitArgs&&>(init_args)...);
     if (on_suspend.fn_)
       on_suspend.fn_(on_suspend.arg_);
   }
@@ -1057,46 +1059,74 @@ private:
   composed_io_executors<Executors> executors_;
 };
 
+template <typename Implementation, typename... Signatures>
+class initiate_co_composed<Implementation, void(), Signatures...>
+{
+public:
+  template <typename I>
+  initiate_co_composed(I&& impl, composed_io_executors<void()>&&)
+    : implementation_(static_cast<I&&>(impl))
+  {
+  }
+
+  template <typename Handler, typename... InitArgs>
+  void operator()(Handler&& handler, InitArgs&&... init_args) const &
+  {
+    using handler_type = decay_t<Handler>;
+    using returns_type = co_composed_returns<Signatures...>;
+    co_composed_on_suspend on_suspend{};
+    implementation_(
+        co_composed_state<void(), handler_type, returns_type>(
+          composed_io_executors<void()>(),
+          static_cast<Handler&&>(handler), on_suspend),
+        static_cast<InitArgs&&>(init_args)...);
+    if (on_suspend.fn_)
+      on_suspend.fn_(on_suspend.arg_);
+  }
+
+  template <typename Handler, typename... InitArgs>
+  void operator()(Handler&& handler, InitArgs&&... init_args) &&
+  {
+    using handler_type = decay_t<Handler>;
+    using returns_type = co_composed_returns<Signatures...>;
+    co_composed_on_suspend on_suspend{};
+    std::move(implementation_)(
+        co_composed_state<void(), handler_type, returns_type>(
+          composed_io_executors<void()>(),
+          static_cast<Handler&&>(handler), on_suspend),
+        static_cast<InitArgs&&>(init_args)...);
+    if (on_suspend.fn_)
+      on_suspend.fn_(on_suspend.arg_);
+  }
+
+private:
+  Implementation implementation_;
+};
+
 template <typename... Signatures, typename Implementation, typename Executors>
-inline initiate_co_composed<Implementation, Executors, Signatures...>
+inline initiate_co_composed<decay_t<Implementation>, Executors, Signatures...>
 make_initiate_co_composed(Implementation&& implementation,
     composed_io_executors<Executors>&& executors)
 {
   return initiate_co_composed<
     decay_t<Implementation>, Executors, Signatures...>(
-        std::forward<Implementation>(implementation), std::move(executors));
+        static_cast<Implementation&&>(implementation), std::move(executors));
 }
 
 } // namespace detail
 
-template <completion_signature... Signatures,
-    typename Implementation, typename... IoObjectsOrExecutors>
-inline auto co_composed(Implementation&& implementation,
-    IoObjectsOrExecutors&&... io_objects_or_executors)
-{
-  return detail::make_initiate_co_composed<Signatures...>(
-      std::forward<Implementation>(implementation),
-      detail::make_composed_io_executors(
-        detail::get_composed_io_executor(
-          std::forward<IoObjectsOrExecutors>(
-            io_objects_or_executors))...));
-}
-
-} // namespace experimental
-
 #if !defined(GENERATING_DOCUMENTATION)
 
 template <template <typename, typename> class Associator,
     typename Executors, typename Handler, typename Return,
     typename Signature, typename DefaultCandidate>
 struct associator<Associator,
-    experimental::detail::co_composed_handler<
-      Executors, Handler, Return, Signature>,
+    detail::co_composed_handler<Executors, Handler, Return, Signature>,
     DefaultCandidate>
   : Associator<Handler, DefaultCandidate>
 {
   static typename Associator<Handler, DefaultCandidate>::type get(
-      const experimental::detail::co_composed_handler<
+      const detail::co_composed_handler<
         Executors, Handler, Return, Signature>& h) noexcept
   {
     return Associator<Handler, DefaultCandidate>::get(
@@ -1104,7 +1134,7 @@ struct associator<Associator,
   }
 
   static auto get(
-      const experimental::detail::co_composed_handler<
+      const detail::co_composed_handler<
         Executors, Handler, Return, Signature>& h,
       const DefaultCandidate& c) noexcept
     -> decltype(
@@ -1131,37 +1161,28 @@ namespace std { namespace experimental {
 template <typename C, typename Executors,
     typename Handler, typename Return, typename... Args>
 struct coroutine_traits<void, C&,
-    boost::asio::experimental::detail::co_composed_state<
-      Executors, Handler, Return>,
-    Args...>
+    boost::asio::detail::co_composed_state<Executors, Handler, Return>, Args...>
 {
   using promise_type =
-    boost::asio::experimental::detail::co_composed_promise<
-      Executors, Handler, Return>;
+    boost::asio::detail::co_composed_promise<Executors, Handler, Return>;
 };
 
 template <typename C, typename Executors,
     typename Handler, typename Return, typename... Args>
 struct coroutine_traits<void, C&&,
-    boost::asio::experimental::detail::co_composed_state<
-      Executors, Handler, Return>,
-    Args...>
+    boost::asio::detail::co_composed_state<Executors, Handler, Return>, Args...>
 {
   using promise_type =
-    boost::asio::experimental::detail::co_composed_promise<
-      Executors, Handler, Return>;
+    boost::asio::detail::co_composed_promise<Executors, Handler, Return>;
 };
 
 template <typename Executors, typename Handler,
     typename Return, typename... Args>
 struct coroutine_traits<void,
-    boost::asio::experimental::detail::co_composed_state<
-      Executors, Handler, Return>,
-    Args...>
+    boost::asio::detail::co_composed_state<Executors, Handler, Return>, Args...>
 {
   using promise_type =
-    boost::asio::experimental::detail::co_composed_promise<
-      Executors, Handler, Return>;
+    boost::asio::detail::co_composed_promise<Executors, Handler, Return>;
 };
 
 # if defined(BOOST_ASIO_HAS_STD_COROUTINE)
@@ -1171,6 +1192,132 @@ struct coroutine_traits<void,
 # endif // defined(BOOST_ASIO_HAS_STD_COROUTINE)
 #endif // !defined(GENERATING_DOCUMENTATION)
 
+namespace boost {
+namespace asio {
+
+/// Creates an initiation function object that may be used to launch a
+/// coroutine-based composed asynchronous operation.
+/**
+ * The co_composed utility simplifies the implementation of composed
+ * asynchronous operations by automatically adapting a coroutine to be an
+ * initiation function object for use with @c async_initiate. When awaiting
+ * asynchronous operations, the coroutine automatically uses a conforming
+ * intermediate completion handler.
+ *
+ * @param implementation A function object that contains the coroutine-based
+ * implementation of the composed asynchronous operation. The first argument to
+ * the function object represents the state of the operation, and may be used
+ * to test for cancellation. The remaining arguments are those passed to @c
+ * async_initiate after 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 while the operation is incomplete.
+ *
+ * @par Per-Operation Cancellation
+ * By default, terminal per-operation cancellation is enabled for composed
+ * operations that use co_composed. To disable cancellation for the composed
+ * operation, or to alter its supported cancellation types, call the state's
+ * @c reset_cancellation_state function.
+ *
+ * @par Examples
+ * The following example illustrates manual error handling and explicit checks
+ * for cancellation. The completion handler is invoked via a @c co_yield to the
+ * state's @c complete function, which never returns.
+ *
+ * @code template <typename CompletionToken>
+ * auto async_echo(tcp::socket& socket,
+ *     CompletionToken&& token)
+ * {
+ *   return boost::asio::async_initiate<
+ *     CompletionToken, void(boost::system::error_code)>(
+ *       boost::asio::co_composed(
+ *         [](auto state, tcp::socket& socket) -> void
+ *         {
+ *           state.reset_cancellation_state(
+ *             boost::asio::enable_terminal_cancellation());
+ *
+ *           while (!state.cancelled())
+ *           {
+ *             char data[1024];
+ *             auto [e1, n1] =
+ *               co_await socket.async_read_some(
+ *                 boost::asio::buffer(data));
+ *
+ *             if (e1)
+ *               co_yield state.complete(e1);
+ *
+ *             if (!!state.cancelled())
+ *               co_yield state.complete(
+ *                 make_error_code(boost::asio::error::operation_aborted));
+ *
+ *             auto [e2, n2] =
+ *               co_await boost::asio::async_write(socket,
+ *                 boost::asio::buffer(data, n1));
+ *
+ *             if (e2)
+ *               co_yield state.complete(e2);
+ *           }
+ *         }, socket),
+ *       token, std::ref(socket));
+ * } @endcode
+ *
+ * This next example shows exception-based error handling and implicit checks
+ * for cancellation. The completion handler is invoked after returning from the
+ * coroutine via @c co_return. Valid @c co_return values are specified using
+ * completion signatures passed to the @c co_composed function.
+ *
+ * @code template <typename CompletionToken>
+ * auto async_echo(tcp::socket& socket,
+ *     CompletionToken&& token)
+ * {
+ *   return boost::asio::async_initiate<
+ *     CompletionToken, void(boost::system::error_code)>(
+ *       boost::asio::co_composed<
+ *         void(boost::system::error_code)>(
+ *           [](auto state, tcp::socket& socket) -> void
+ *           {
+ *             try
+ *             {
+ *               state.throw_if_cancelled(true);
+ *               state.reset_cancellation_state(
+ *                 boost::asio::enable_terminal_cancellation());
+ *
+ *               for (;;)
+ *               {
+ *                 char data[1024];
+ *                 std::size_t n = co_await socket.async_read_some(
+ *                     boost::asio::buffer(data));
+ *
+ *                 co_await boost::asio::async_write(socket,
+ *                     boost::asio::buffer(data, n));
+ *               }
+ *             }
+ *             catch (const boost::system::system_error& e)
+ *             {
+ *               co_return {e.code()};
+ *             }
+ *           }, socket),
+ *       token, std::ref(socket));
+ * } @endcode
+ */
+template <BOOST_ASIO_COMPLETION_SIGNATURE... Signatures,
+    typename Implementation, typename... IoObjectsOrExecutors>
+inline auto co_composed(Implementation&& implementation,
+    IoObjectsOrExecutors&&... io_objects_or_executors)
+{
+  return detail::make_initiate_co_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
+} // namespace boost
+
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // BOOST_ASIO_IMPL_EXPERIMENTAL_CO_COMPOSED_HPP
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT) || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_CO_COMPOSED_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/completion_condition.hpp

@@ -17,6 +17,8 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/system/error_code.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -98,8 +100,55 @@ private:
   std::size_t size_;
 };
 
+template <typename T, typename = void>
+struct is_completion_condition_helper : false_type
+{
+};
+
+template <typename T>
+struct is_completion_condition_helper<T,
+    enable_if_t<
+      is_same<
+        result_of_t<T(boost::system::error_code, std::size_t)>,
+        bool
+      >::value
+    >
+  > : true_type
+{
+};
+
+template <typename T>
+struct is_completion_condition_helper<T,
+    enable_if_t<
+      is_same<
+        result_of_t<T(boost::system::error_code, std::size_t)>,
+        std::size_t
+      >::value
+    >
+  > : true_type
+{
+};
+
 } // namespace detail
 
+#if defined(GENERATING_DOCUMENTATION)
+
+/// Trait for determining whether a function object is a completion condition.
+template <typename T>
+struct is_completion_condition
+{
+  static constexpr bool value = automatically_determined;
+};
+
+#else // defined(GENERATING_DOCUMENTATION)
+
+template <typename T>
+struct is_completion_condition : detail::is_completion_condition_helper<T>
+{
+};
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
 /**
  * @defgroup completion_condition Completion Condition Function Objects
  *