passenger 6.0.16 → 6.0.18

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

@@ -16,247 +16,193 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#include <boost/asio/deferred.hpp>
+#include <boost/asio/experimental/coro.hpp>
+
 #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;
+#if !defined(GENERATING_DOCUMENTATION)
 
-template <typename Executor, typename... Ts>
-struct coro_init_handler
+template <typename Allocator, typename R>
+struct async_result<experimental::use_coro_t<Allocator>, R()>
 {
-  struct handler_t
+  template <typename Initiation, typename... InitArgs>
+  static auto initiate_impl(Initiation initiation,
+      std::allocator_arg_t, Allocator, InitArgs... args)
+    -> experimental::coro<void() noexcept, void,
+      boost::asio::associated_executor_t<Initiation>, Allocator>
   {
-  };
-
-  constexpr static handler_t handler{};
+    co_await deferred_async_operation<R(), Initiation, InitArgs...>(
+        deferred_init_tag{}, std::move(initiation), std::move(args)...);
+  }
 
-  struct init_helper;
+  template <typename... InitArgs>
+  static auto initiate_impl(boost::asio::detail::initiation_archetype<R()>,
+      std::allocator_arg_t, Allocator, InitArgs... args)
+    -> experimental::coro<void(), void,
+      boost::asio::any_io_executor, Allocator>;
 
-  struct promise_type
+  template <typename Initiation, typename... InitArgs>
+  static auto initiate(Initiation initiation,
+      experimental::use_coro_t<Allocator> tk, InitArgs&&... args)
   {
-    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;
-  };
+    return initiate_impl(std::move(initiation), std::allocator_arg,
+        tk.get_allocator(), std::forward<InitArgs>(args)...);
+  }
+};
 
-  struct init_helper
+template <typename Allocator, typename R>
+struct async_result<
+    experimental::use_coro_t<Allocator>, R(boost::system::error_code)>
+{
+  template <typename Initiation, typename... InitArgs>
+  static auto initiate_impl(Initiation initiation,
+      std::allocator_arg_t, Allocator, InitArgs... args)
+    -> experimental::coro<void() noexcept, void,
+      boost::asio::associated_executor_t<Initiation>, Allocator>
   {
-    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();
-          }));
-    }
-  };
+    co_await deferred_async_operation<
+      R(boost::system::error_code), Initiation, InitArgs...>(
+        deferred_init_tag{}, std::move(initiation), std::move(args)...);
+  }
 
-  promise_type* promise;
+  template <typename... InitArgs>
+  static auto initiate_impl(
+      boost::asio::detail::initiation_archetype<R(boost::system::error_code)>,
+      std::allocator_arg_t, Allocator, InitArgs... args)
+    -> experimental::coro<void(), void,
+      boost::asio::any_io_executor, Allocator>;
 
-  void unhandled_exception() noexcept
+  template <typename Initiation, typename... InitArgs>
+  static auto initiate(Initiation initiation,
+      experimental::use_coro_t<Allocator> tk, InitArgs&&... args)
   {
-    throw;
+    return initiate_impl(std::move(initiation), std::allocator_arg,
+        tk.get_allocator(), std::forward<InitArgs>(args)...);
   }
+};
 
-  struct noexcept_version
+template <typename Allocator, typename R>
+struct async_result<
+    experimental::use_coro_t<Allocator>, R(std::exception_ptr)>
+{
+  template <typename Initiation, typename... InitArgs>
+  static auto initiate_impl(Initiation initiation,
+      std::allocator_arg_t, Allocator, InitArgs... args)
+    -> experimental::coro<void(), void,
+      boost::asio::associated_executor_t<Initiation>, Allocator>
   {
-    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<>&&) {}
+    co_await deferred_async_operation<
+      R(boost::system::error_code), Initiation, InitArgs...>(
+        deferred_init_tag{}, std::move(initiation), std::move(args)...);
+  }
 
-    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));
-    }
-  };
+  template <typename... InitArgs>
+  static auto initiate_impl(
+      boost::asio::detail::initiation_archetype<R(std::exception_ptr)>,
+      std::allocator_arg_t, Allocator, InitArgs... args)
+    -> experimental::coro<void(), void,
+      boost::asio::any_io_executor, Allocator>;
 
-  struct throwing_version
+  template <typename Initiation, typename... InitArgs>
+  static auto initiate(Initiation initiation,
+      experimental::use_coro_t<Allocator> tk, InitArgs&&... args)
   {
-    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>{});
-    }
+    return initiate_impl(std::move(initiation), std::allocator_arg,
+        tk.get_allocator(), std::forward<InitArgs>(args)...);
+  }
+};
 
-    static auto resume_impl(std::tuple<std::exception_ptr>&& tup)
-    {
-      auto ex = get<0>(std::move(tup));
-      if (ex)
-        std::rethrow_exception(ex);
-    }
+template <typename Allocator, typename R, typename T>
+struct async_result<experimental::use_coro_t<Allocator>, R(T)>
+{
 
-    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");
-    }
+  template <typename Initiation, typename... InitArgs>
+  static auto initiate_impl(Initiation initiation,
+      std::allocator_arg_t, Allocator, InitArgs... args)
+    -> experimental::coro<void() noexcept, T,
+      boost::asio::associated_executor_t<Initiation>, Allocator>
+  {
+    co_return co_await deferred_async_operation<R(), Initiation, InitArgs...>(
+        deferred_init_tag{}, std::move(initiation), std::move(args)...);
+  }
 
-    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));
-    }
-  };
+  template <typename... InitArgs>
+  static auto initiate_impl(boost::asio::detail::initiation_archetype<R(T)>,
+      std::allocator_arg_t, Allocator, InitArgs... args)
+    -> experimental::coro<void() noexcept, T,
+      boost::asio::any_io_executor, Allocator>;
 
-  auto as_noexcept(cancellation_slot&& sl) && noexcept
+  template <typename Initiation, typename... InitArgs>
+  static auto initiate(Initiation initiation,
+      experimental::use_coro_t<Allocator> tk, InitArgs&&... args)
   {
-    promise->cancel_slot = std::move(sl);
-    return noexcept_version{promise};
+    return initiate_impl(std::move(initiation), std::allocator_arg,
+        tk.get_allocator(), std::forward<InitArgs>(args)...);
   }
+};
 
-  auto as_throwing(cancellation_slot&& sl) && noexcept
+template <typename Allocator, typename R, typename T>
+struct async_result<
+    experimental::use_coro_t<Allocator>, R(boost::system::error_code, T)>
+{
+  template <typename Initiation, typename... InitArgs>
+  static auto initiate_impl(Initiation initiation,
+      std::allocator_arg_t, Allocator, InitArgs... args)
+    -> experimental::coro<void(), T,
+      boost::asio::associated_executor_t<Initiation>, Allocator>
   {
-    promise->cancel_slot = std::move(sl);
-    return throwing_version{promise};
+    co_return co_await deferred_async_operation<
+      R(boost::system::error_code), Initiation, InitArgs...>(
+        deferred_init_tag{}, std::move(initiation), std::move(args)...);
   }
-};
 
-} // namespace detail
-} // namespace experimental
+  template <typename... InitArgs>
+  static auto initiate_impl(
+      boost::asio::detail::initiation_archetype<
+        R(boost::system::error_code, T)>,
+      std::allocator_arg_t, Allocator, InitArgs... args)
+    -> experimental::coro<void(), T, boost::asio::any_io_executor, Allocator>;
 
-#if !defined(GENERATING_DOCUMENTATION)
+  template <typename Initiation, typename... InitArgs>
+  static auto initiate(Initiation initiation,
+      experimental::use_coro_t<Allocator> tk, InitArgs&&... args)
+  {
+    return initiate_impl(std::move(initiation), std::allocator_arg,
+        tk.get_allocator(), std::forward<InitArgs>(args)...);
+  }
+};
 
-template <typename Executor, typename R, typename... Args>
-struct async_result<experimental::use_coro_t<Executor>, R(Args...)>
+template <typename Allocator, typename R, typename T>
+struct async_result<
+    experimental::use_coro_t<Allocator>, R(std::exception_ptr, T)>
 {
-  using return_type = experimental::detail::coro_init_handler<
-    Executor, typename decay<Args>::type...>;
+  template <typename Initiation, typename... InitArgs>
+  static auto initiate_impl(Initiation initiation,
+      std::allocator_arg_t, Allocator, InitArgs... args)
+    -> experimental::coro<void(), T,
+      boost::asio::associated_executor_t<Initiation>, Allocator>
+  {
+    co_return co_await deferred_async_operation<
+      R(boost::system::error_code), Initiation, InitArgs...>(
+        deferred_init_tag{}, std::move(initiation), std::move(args)...);
+  }
+
+  template <typename... InitArgs>
+  static auto initiate_impl(
+      boost::asio::detail::initiation_archetype<R(std::exception_ptr, T)>,
+      std::allocator_arg_t, Allocator, InitArgs... args)
+    -> experimental::coro<void(), T, boost::asio::any_io_executor, Allocator>;
 
   template <typename Initiation, typename... InitArgs>
-  static return_type initiate(Initiation initiation,
-      experimental::use_coro_t<Executor>, InitArgs... args)
+  static auto initiate(Initiation initiation,
+      experimental::use_coro_t<Allocator> tk, InitArgs&&... args)
   {
-    std::move(initiation)(co_await return_type::handler, std::move(args)...);
+    return initiate_impl(std::move(initiation), std::allocator_arg,
+        tk.get_allocator(), std::forward<InitArgs>(args)...);
   }
 };
 

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

@@ -0,0 +1,68 @@
+//
+// experimental/impl/use_promise.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_PROMISE_HPP
+#define BOOST_ASIO_EXPERIMENTAL_IMPL_USE_PROMISE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <memory>
+#include <boost/asio/async_result.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+
+template <typename Allocator>
+struct use_promise_t;
+
+namespace detail {
+
+template<typename Signature, typename Executor, typename Allocator>
+struct promise_handler;
+
+} // namespace detail
+} // namespace experimental
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename Allocator, typename R, typename... Args>
+struct async_result<experimental::use_promise_t<Allocator>, R(Args...)>
+{
+  template <typename Initiation, typename... InitArgs>
+  static auto initiate(Initiation initiation,
+      experimental::use_promise_t<Allocator> up, InitArgs... args)
+    -> experimental::promise<void(typename decay<Args>::type...),
+      boost::asio::associated_executor_t<Initiation>, Allocator>
+  {
+    using handler_type = experimental::detail::promise_handler<
+      void(typename decay<Args>::type...),
+      boost::asio::associated_executor_t<Initiation>, Allocator>;
+
+    handler_type ht{up.get_allocator(), get_associated_executor(initiation)};
+    std::move(initiation)(ht, std::move(args)...);
+    return ht.make_promise();
+  }
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_IMPL_USE_PROMISE_HPP