passenger 6.0.22 → 6.0.24

data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/parallel_group.hpp

@@ -208,6 +208,36 @@ public:
 /**
  * For example:
  * @code boost::asio::experimental::make_parallel_group(
+ *    in.async_read_some(boost::asio::buffer(data)),
+ *    timer.async_wait()
+ *  ).async_wait(
+ *    boost::asio::experimental::wait_for_all(),
+ *    [](
+ *        std::array<std::size_t, 2> completion_order,
+ *        boost::system::error_code ec1, std::size_t n1,
+ *        boost::system::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 boost::asio::experimental::make_parallel_group(
  *    [&](auto token)
  *    {
  *      return in.async_read_some(boost::asio::buffer(data), token);
@@ -333,28 +363,12 @@ public:
  *
  * For example:
  * @code
- * using op_type = decltype(
- *     socket1.async_read_some(
- *       boost::asio::buffer(data1),
- *       boost::asio::deferred
- *     )
- *   );
+ * using op_type =
+ *   decltype(socket1.async_read_some(boost::asio::buffer(data1)));
  *
  * std::vector<op_type> ops;
- *
- * ops.push_back(
- *     socket1.async_read_some(
- *       boost::asio::buffer(data1),
- *       boost::asio::deferred
- *     )
- *   );
- *
- * ops.push_back(
- *     socket2.async_read_some(
- *       boost::asio::buffer(data2),
- *       boost::asio::deferred
- *     )
- *   );
+ * ops.push_back(socket1.async_read_some(boost::asio::buffer(data1)));
+ * ops.push_back(socket2.async_read_some(boost::asio::buffer(data2)));
  *
  * boost::asio::experimental::make_parallel_group(ops).async_wait(
  *     boost::asio::experimental::wait_for_all(),
@@ -392,28 +406,12 @@ make_parallel_group(Range&& range,
  *
  * For example:
  * @code
- * using op_type = decltype(
- *     socket1.async_read_some(
- *       boost::asio::buffer(data1),
- *       boost::asio::deferred
- *     )
- *   );
+ * using op_type =
+ *   decltype(socket1.async_read_some(boost::asio::buffer(data1)));
  *
  * std::vector<op_type> ops;
- *
- * ops.push_back(
- *     socket1.async_read_some(
- *       boost::asio::buffer(data1),
- *       boost::asio::deferred
- *     )
- *   );
- *
- * ops.push_back(
- *     socket2.async_read_some(
- *       boost::asio::buffer(data2),
- *       boost::asio::deferred
- *     )
- *   );
+ * ops.push_back(socket1.async_read_some(boost::asio::buffer(data1)));
+ * ops.push_back(socket2.async_read_some(boost::asio::buffer(data2)));
  *
  * boost::asio::experimental::make_parallel_group(
  *     std::allocator_arg_t,

data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/promise.hpp

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

data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/use_coro.hpp

@@ -48,8 +48,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 boost::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 boost::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
@@ -84,7 +85,6 @@ struct use_coro_t
   {
   }
 
-
   /// Specify an alternate allocator.
   template <typename OtherAllocator>
   use_coro_t<OtherAllocator> rebind(const OtherAllocator& allocator) const
@@ -174,9 +174,9 @@ private:
  * See the documentation for boost::asio::use_coro_t for a usage example.
  */
 #if defined(GENERATING_DOCUMENTATION)
-constexpr use_coro_t<> use_coro;
+BOOST_ASIO_INLINE_VARIABLE constexpr use_coro_t<> use_coro;
 #else
-constexpr use_coro_t<> use_coro(0, 0, 0);
+BOOST_ASIO_INLINE_VARIABLE constexpr use_coro_t<> use_coro(0, 0, 0);
 #endif
 
 } // namespace experimental

data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/use_promise.hpp

@@ -100,7 +100,7 @@ private:
   Allocator allocator_;
 };
 
-constexpr use_promise_t<> use_promise;
+BOOST_ASIO_INLINE_VARIABLE constexpr use_promise_t<> use_promise;
 
 } // namespace experimental
 } // namespace asio

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

@@ -0,0 +1,144 @@
+//
+// 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 BOOST_ASIO_IMMEDIATE_HPP
+#define BOOST_ASIO_IMMEDIATE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/associated_immediate_executor.hpp>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/dispatch.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+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
+ * boost::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 boost::asio::post()
+ * on the supplied I/O executor.
+ *
+ * @par Completion Signature
+ * @code void() @endcode
+ */
+template <typename Executor,
+    BOOST_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
+ * boost::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 boost::asio::post()
+ * on the I/O executor obtained from the supplied execution context.
+ *
+ * @par Completion Signature
+ * @code void() @endcode
+ */
+template <typename ExecutionContext,
+    BOOST_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
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMMEDIATE_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/append.hpp

@@ -19,6 +19,7 @@
 #include <boost/asio/associator.hpp>
 #include <boost/asio/async_result.hpp>
 #include <boost/asio/detail/handler_cont_helpers.hpp>
+#include <boost/asio/detail/initiation_base.hpp>
 #include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/detail/utility.hpp>
 
@@ -94,25 +95,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/src/cxx_supportlib/vendor-modified/boost/asio/impl/as_tuple.hpp

@@ -17,9 +17,11 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <tuple>
+#include <boost/asio/associated_executor.hpp>
 #include <boost/asio/associator.hpp>
 #include <boost/asio/async_result.hpp>
 #include <boost/asio/detail/handler_cont_helpers.hpp>
+#include <boost/asio/detail/initiation_base.hpp>
 #include <boost/asio/detail/type_traits.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -119,23 +121,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>
@@ -172,23 +178,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>
@@ -237,6 +247,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

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/awaitable.hpp

@@ -546,7 +546,7 @@ public:
   {
     this->coro_ = coroutine_handle<awaitable_frame>::from_promise(*this);
     return awaitable<T, Executor>(this);
-  };
+  }
 
   template <typename U>
   void return_value(U&& u)
@@ -583,7 +583,7 @@ public:
   {
     this->coro_ = coroutine_handle<awaitable_frame>::from_promise(*this);
     return awaitable<void, Executor>(this);
-  };
+  }
 
   void return_void()
   {
@@ -621,7 +621,7 @@ public:
   {
     this->coro_ = coroutine_handle<awaitable_frame>::from_promise(*this);
     return awaitable<awaitable_thread_entry_point, Executor>(this);
-  };
+  }
 
   void return_void()
   {