passenger 6.0.14 → 6.0.15

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

@@ -2,7 +2,7 @@
 // experimental/impl/parallel_group.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)
@@ -107,11 +107,11 @@ struct parallel_group_completion_handler
 
   void operator()()
   {
-    this->invoke(std::make_index_sequence<sizeof...(Ops)>());
+    this->invoke(boost::asio::detail::make_index_sequence<sizeof...(Ops)>());
   }
 
   template <std::size_t... I>
-  void invoke(std::index_sequence<I...>)
+  void invoke(boost::asio::detail::index_sequence<I...>)
   {
     this->invoke(std::tuple_cat(std::move(std::get<I>(args_).get())...));
   }
@@ -119,11 +119,13 @@ struct parallel_group_completion_handler
   template <typename... Args>
   void invoke(std::tuple<Args...>&& args)
   {
-    this->invoke(std::move(args), std::make_index_sequence<sizeof...(Args)>());
+    this->invoke(std::move(args),
+        boost::asio::detail::index_sequence_for<Args...>());
   }
 
   template <typename... Args, std::size_t... I>
-  void invoke(std::tuple<Args...>&& args, std::index_sequence<I...>)
+  void invoke(std::tuple<Args...>&& args,
+      boost::asio::detail::index_sequence<I...>)
   {
     std::move(handler_)(completion_order_, std::move(std::get<I>(args))...);
   }
@@ -134,7 +136,7 @@ struct parallel_group_completion_handler
   std::tuple<
       parallel_group_op_result<
         typename parallel_op_signature_as_tuple<
-          typename parallel_op_signature<Ops>::type
+          typename completion_signature_of<Ops>::type
         >::type
       >...
     > args_{};
@@ -345,18 +347,19 @@ struct parallel_group_cancellation_handler
     // yet completed and requested cancellation, emit a signal for each
     // operation in the group.
     if (cancel_type != cancellation_type::none)
-      if (state_->cancellations_requested_++ == 0)
-        for (std::size_t i = 0; i < sizeof...(Ops); ++i)
-          state_->cancellation_signals_[i].emit(cancel_type);
+      if (auto state = state_.lock())
+        if (state->cancellations_requested_++ == 0)
+          for (std::size_t i = 0; i < sizeof...(Ops); ++i)
+            state->cancellation_signals_[i].emit(cancel_type);
   }
 
-  std::shared_ptr<parallel_group_state<Condition, Handler, Ops...> > state_;
+  std::weak_ptr<parallel_group_state<Condition, Handler, Ops...> > state_;
 };
 
 template <typename Condition, typename Handler,
     typename... Ops, std::size_t... I>
 void parallel_group_launch(Condition cancellation_condition, Handler handler,
-    std::tuple<Ops...>& ops, std::index_sequence<I...>)
+    std::tuple<Ops...>& ops, boost::asio::detail::index_sequence<I...>)
 {
   // Get the user's completion handler's cancellation slot, so that we can allow
   // cancellation of the entire group.
@@ -393,23 +396,6 @@ void parallel_group_launch(Condition cancellation_condition, Handler handler,
 } // namespace detail
 } // namespace experimental
 
-template <typename R, typename... Args>
-class async_result<
-    experimental::detail::parallel_op_signature_probe,
-    R(Args...)>
-{
-public:
-  typedef experimental::detail::parallel_op_signature_probe_result<
-    void(Args...)> return_type;
-
-  template <typename Initiation, typename... InitArgs>
-  static return_type initiate(Initiation&&,
-      experimental::detail::parallel_op_signature_probe, InitArgs&&...)
-  {
-    return return_type{};
-  }
-};
-
 template <template <typename, typename> class Associator,
     typename Handler, typename... Ops, typename DefaultCandidate>
 struct associator<Associator,

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

@@ -2,8 +2,8 @@
 // experimental/impl/promise.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2021 Klemens D. Morgenstern
-//                    (klemens dot morgenstern at gmx dot net)
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
 //
 // 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)
@@ -11,6 +11,10 @@
 #ifndef BOOST_ASIO_EXPERIMENTAL_IMPL_PROMISE_HPP
 #define BOOST_ASIO_EXPERIMENTAL_IMPL_PROMISE_HPP
 
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
 #include <boost/asio/cancellation_signal.hpp>
 #include <boost/asio/experimental/detail/completion_handler_erasure.hpp>
 #include <tuple>

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

@@ -0,0 +1,270 @@
+//
+// experimental/impl/use_coro.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
+//
+// 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_EXPERIMENTAL_IMPL_USE_CORO_HPP
+#define BOOST_ASIO_EXPERIMENTAL_IMPL_USE_CORO_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+
+template <typename Yield, typename Return, typename Executor>
+struct coro;
+
+namespace detail {
+
+template <typename Yield, typename Return, typename Executor>
+struct coro_promise;
+
+template <typename Executor, typename... Ts>
+struct coro_init_handler
+{
+  struct handler_t
+  {
+  };
+
+  constexpr static handler_t handler{};
+
+  struct init_helper;
+
+  struct promise_type
+  {
+    auto initial_suspend() noexcept { return suspend_always{}; }
+
+    auto final_suspend() noexcept { return suspend_always(); }
+
+    void return_void() {}
+
+    void unhandled_exception() { assert(false); }
+
+    auto await_transform(handler_t)
+    {
+      assert(executor);
+      assert(h);
+      return init_helper{this};
+    }
+
+    std::optional<Executor> executor;
+    std::optional<std::tuple<Ts...>> result;
+    coroutine_handle<> h;
+
+    coro_init_handler get_return_object() { return coro_init_handler{this}; }
+
+    cancellation_slot cancel_slot;
+  };
+
+  struct init_helper
+  {
+    promise_type *self_;
+
+    constexpr static bool await_ready() noexcept { return true; }
+
+    constexpr static void await_suspend(coroutine_handle<>) noexcept {}
+
+    auto await_resume() const noexcept
+    {
+      assert(self_);
+      return bind_cancellation_slot(self_->cancel_slot,
+          bind_executor(*self_->executor, [self = self_](Ts... ts)
+          {
+            self->cancel_slot.clear();
+            self->result.emplace(std::move(ts)...);
+            self->h.resume();
+          }));
+    }
+  };
+
+  promise_type* promise;
+
+  void unhandled_exception() noexcept
+  {
+    throw;
+  }
+
+  struct noexcept_version
+  {
+    promise_type *promise;
+
+    constexpr static bool await_ready() noexcept { return false; }
+
+    template <typename Yield, typename Return,
+        convertible_to<Executor> Executor1>
+    auto await_suspend(
+        coroutine_handle<coro_promise<Yield, Return, Executor1> > h) noexcept
+    {
+      promise->executor = h.promise().get_executor();
+      promise->h = h;
+      return coroutine_handle<promise_type>::from_promise(*promise);
+    }
+
+    template <typename... Args>
+    static auto resume_impl(std::tuple<Args...>&& tup)
+    {
+      return std::move(tup);
+    }
+
+    template <typename Arg>
+    static auto resume_impl(std::tuple<Arg>&& tup)
+    {
+      return get<0>(std::move(tup));
+    }
+
+    static void resume_impl(std::tuple<>&&) {}
+
+    auto await_resume() const noexcept
+    {
+      auto res = std::move(promise->result.value());
+      coroutine_handle<promise_type>::from_promise(*promise).destroy();
+      return resume_impl(std::move(res));
+    }
+  };
+
+  struct throwing_version
+  {
+    promise_type *promise;
+
+    constexpr static bool await_ready() noexcept { return false; }
+
+    template <typename Yield, typename Return,
+        convertible_to<Executor> Executor1>
+    auto await_suspend(
+        coroutine_handle<coro_promise<Yield, Return, Executor1> > h) noexcept
+    {
+      promise->executor = h.promise().get_executor();
+      promise->h = h;
+      return coroutine_handle<promise_type>::from_promise(*promise);
+    }
+
+    template <typename... Args>
+    static auto resume_impl(std::tuple<Args...>&& tup)
+    {
+      return std::move(tup);
+    }
+
+    static void resume_impl(std::tuple<>&&) {}
+
+    template <typename Arg>
+    static auto resume_impl(std::tuple<Arg>&& tup)
+    {
+      return get<0>(std::move(tup));
+    }
+
+    template <typename... Args>
+    static auto resume_impl(std::tuple<std::exception_ptr, Args...>&& tup)
+    {
+      auto ex = get<0>(std::move(tup));
+      if (ex)
+        std::rethrow_exception(ex);
+
+      if constexpr (sizeof...(Args) == 0u)
+        return;
+      else if constexpr (sizeof...(Args) == 1u)
+        return get<1>(std::move(tup));
+      else
+      {
+        return
+          [&]<std::size_t... Idx>(std::index_sequence<Idx...>)
+          {
+            return std::make_tuple(std::get<Idx + 1>(std::move(tup))...);
+          }(std::make_index_sequence<sizeof...(Args) - 1>{});
+      }
+    }
+
+    template <typename... Args>
+    static auto resume_impl(
+        std::tuple<boost::system::error_code, Args...>&& tup)
+    {
+      auto ec = get<0>(std::move(tup));
+      if (ec)
+        boost::asio::detail::throw_exception(
+            boost::system::system_error(ec, "error_code in use_coro"));
+
+      if constexpr (sizeof...(Args) == 0u)
+        return;
+      else if constexpr (sizeof...(Args) == 1u)
+        return get<1>(std::move(tup));
+      else
+        return
+          [&]<std::size_t... Idx>(std::index_sequence<Idx...>)
+          {
+            return std::make_tuple(std::get<Idx + 1>(std::move(tup))...);
+          }(std::make_index_sequence<sizeof...(Args) - 1>{});
+    }
+
+    static auto resume_impl(std::tuple<std::exception_ptr>&& tup)
+    {
+      auto ex = get<0>(std::move(tup));
+      if (ex)
+        std::rethrow_exception(ex);
+    }
+
+    static auto resume_impl(
+        std::tuple<boost::system::error_code>&& tup)
+    {
+      auto ec = get<0>(std::move(tup));
+      if (ec)
+        boost::asio::detail::throw_error(ec, "error_code in use_coro");
+    }
+
+    auto await_resume() const
+    {
+      auto res = std::move(promise->result.value());
+      coroutine_handle<promise_type>::from_promise(*promise).destroy();
+      return resume_impl(std::move(res));
+    }
+  };
+
+  auto as_noexcept(cancellation_slot&& sl) && noexcept
+  {
+    promise->cancel_slot = std::move(sl);
+    return noexcept_version{promise};
+  }
+
+  auto as_throwing(cancellation_slot&& sl) && noexcept
+  {
+    promise->cancel_slot = std::move(sl);
+    return throwing_version{promise};
+  }
+};
+
+} // namespace detail
+} // namespace experimental
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename Executor, typename R, typename... Args>
+struct async_result<experimental::use_coro_t<Executor>, R(Args...)>
+{
+  using return_type = experimental::detail::coro_init_handler<
+    Executor, typename decay<Args>::type...>;
+
+  template <typename Initiation, typename... InitArgs>
+  static return_type initiate(Initiation initiation,
+      experimental::use_coro_t<Executor>, InitArgs... args)
+  {
+    std::move(initiation)(co_await return_type::handler, std::move(args)...);
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_IMPL_USE_CORO_HPP

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

@@ -2,7 +2,7 @@
 // experimental/parallel_group.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)
@@ -16,8 +16,8 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <utility>
 #include <boost/asio/detail/array.hpp>
+#include <boost/asio/detail/utility.hpp>
 #include <boost/asio/experimental/cancellation_condition.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -27,23 +27,6 @@ namespace asio {
 namespace experimental {
 namespace detail {
 
-// Helper trait for getting the completion signature from an async operation.
-
-struct parallel_op_signature_probe {};
-
-template <typename T>
-struct parallel_op_signature_probe_result
-{
-  typedef T type;
-};
-
-template <typename Op>
-struct parallel_op_signature
-{
-  typedef typename decltype(declval<Op>()(
-    declval<parallel_op_signature_probe>()))::type type;
-};
-
 // Helper trait for getting a tuple from a completion signature.
 
 template <typename Signature>
@@ -94,7 +77,7 @@ struct parallel_group_signature<N, Sig0, Sig1, SigN...>
 template <typename Condition, typename Handler,
     typename... Ops, std::size_t... I>
 void parallel_group_launch(Condition cancellation_condition, Handler handler,
-    std::tuple<Ops...>& ops, std::index_sequence<I...>);
+    std::tuple<Ops...>& ops, boost::asio::detail::index_sequence<I...>);
 
 } // namespace detail
 
@@ -106,6 +89,20 @@ void parallel_group_launch(Condition cancellation_condition, Handler handler,
 template <typename... Ops>
 class parallel_group
 {
+private:
+  struct initiate_async_wait
+  {
+    template <typename Handler, typename Condition>
+    void operator()(Handler&& h, Condition&& c, std::tuple<Ops...>&& ops) const
+    {
+      detail::parallel_group_launch(
+          std::forward<Condition>(c), std::forward<Handler>(h),
+          ops, boost::asio::detail::index_sequence_for<Ops...>());
+    }
+  };
+
+  std::tuple<Ops...> ops_;
+
 public:
   /// Constructor.
   explicit parallel_group(Ops... ops)
@@ -115,7 +112,7 @@ public:
 
   /// The completion signature for the group of operations.
   typedef typename detail::parallel_group_signature<sizeof...(Ops),
-      typename detail::parallel_op_signature<Ops>::type...>::type signature;
+      typename completion_signature_of<Ops>::type...>::type signature;
 
   /// Initiate an asynchronous wait for the group of operations.
   /**
@@ -128,7 +125,7 @@ public:
    * operations, it must return a boost::asio::cancellation_type value other
    * than <tt>boost::asio::cancellation_type::none</tt>.
    *
-   * @param token A completion token whose signature is comprised of
+   * @param token A @ref completion_token whose signature is comprised of
    * a @c std::array<std::size_t, N> indicating the completion order of the
    * operations, followed by all operations' completion handler arguments.
    *
@@ -141,26 +138,18 @@ public:
    */
   template <typename CancellationCondition,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(signature) CompletionToken>
-  auto async_wait(CancellationCondition cancellation_condition,
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken, signature)
+  async_wait(CancellationCondition cancellation_condition,
       CompletionToken&& token)
+    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+      boost::asio::async_initiate<CompletionToken, signature>(
+          declval<initiate_async_wait>(), token,
+          std::move(cancellation_condition), std::move(ops_))))
   {
     return boost::asio::async_initiate<CompletionToken, signature>(
         initiate_async_wait(), token,
         std::move(cancellation_condition), std::move(ops_));
   }
-
-private:
-  struct initiate_async_wait
-  {
-    template <typename Handler, typename Condition>
-    void operator()(Handler&& h, Condition&& c, std::tuple<Ops...>&& ops) const
-    {
-      detail::parallel_group_launch(std::move(c), std::move(h),
-          ops, std::make_index_sequence<sizeof...(Ops)>());
-    }
-  };
-
-  std::tuple<Ops...> ops_;
 };
 
 /// Create a group of operations that may be launched in parallel.
@@ -201,7 +190,8 @@ private:
  * @endcode
  */
 template <typename... Ops>
-inline parallel_group<Ops...> make_parallel_group(Ops... ops)
+BOOST_ASIO_NODISCARD inline parallel_group<Ops...>
+make_parallel_group(Ops... ops)
 {
   return parallel_group<Ops...>(std::move(ops)...);
 }

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

@@ -2,7 +2,7 @@
 // experimental/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)
@@ -16,8 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <tuple>
-#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/prepend.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -25,42 +24,10 @@ namespace boost {
 namespace asio {
 namespace experimental {
 
-/// Completion token type used to specify that the completion handler
-/// arguments should be passed additional values before the results of the
-/// operation.
-template <typename CompletionToken, typename... Values>
-class prepend_t
-{
-public:
-  /// Constructor.
-  template <typename T, typename... V>
-  BOOST_ASIO_CONSTEXPR explicit prepend_t(
-      BOOST_ASIO_MOVE_ARG(T) completion_token,
-      BOOST_ASIO_MOVE_ARG(V)... values)
-    : token_(BOOST_ASIO_MOVE_CAST(T)(completion_token)),
-      values_(BOOST_ASIO_MOVE_CAST(V)(values)...)
-  {
-  }
-
-//private:
-  CompletionToken token_;
-  std::tuple<Values...> values_;
-};
-
-/// Completion token type used to specify that the completion handler
-/// arguments should be passed additional values before the results of the
-/// operation.
-template <typename CompletionToken, typename... Values>
-inline BOOST_ASIO_CONSTEXPR prepend_t<
-  typename decay<CompletionToken>::type, typename decay<Values>::type...>
-prepend(BOOST_ASIO_MOVE_ARG(CompletionToken) completion_token,
-    BOOST_ASIO_MOVE_ARG(Values)... values)
-{
-  return prepend_t<
-    typename decay<CompletionToken>::type, typename decay<Values>::type...>(
-      BOOST_ASIO_MOVE_CAST(CompletionToken)(completion_token),
-      BOOST_ASIO_MOVE_CAST(Values)(values)...);
-}
+#if !defined(BOOST_ASIO_NO_DEPRECATED)
+using boost::asio::prepend_t;
+using boost::asio::prepend;
+#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
 
 } // namespace experimental
 } // namespace asio
@@ -68,6 +35,4 @@ prepend(BOOST_ASIO_MOVE_ARG(CompletionToken) completion_token,
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#include <boost/asio/experimental/impl/prepend.hpp>
-
 #endif // BOOST_ASIO_EXPERIMENTAL_PREPEND_HPP