passenger 6.0.11 → 6.0.12

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

@@ -0,0 +1,160 @@
+//
+// experimental/detail/completion_handler_erasure.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021 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_DETAIL_COMPLETION_HANDLER_ERASURE_HPP
+#define BOOST_ASIO_EXPERIMENTAL_DETAIL_COMPLETION_HANDLER_ERASURE_HPP
+
+#include <boost/asio/associated_allocator.hpp>
+#include <boost/asio/dispatch.hpp>
+
+namespace boost {
+namespace asio {
+
+class any_io_executor;
+
+namespace experimental {
+namespace detail {
+
+template<typename Signature, typename Executor>
+struct completion_handler_erasure_base;
+
+template<typename Func, typename Signature, typename Executor>
+struct completion_handler_erasure_impl;
+
+template<typename Return,  typename ... Args, typename Executor>
+struct completion_handler_erasure_base<Return(Args...), Executor>
+{
+  Executor executor;
+
+  completion_handler_erasure_base(Executor&& executor)
+    : executor(std::move(executor))
+  {
+  }
+
+  virtual Return call(Args ...args) = 0;
+  virtual ~completion_handler_erasure_base() = default;
+};
+
+template<typename Func, typename Return,  typename ... Args, typename Executor>
+struct completion_handler_erasure_impl<Func, Return(Args...), Executor> final
+    : completion_handler_erasure_base<Return(Args...), Executor>
+{
+  completion_handler_erasure_impl(Executor&& exec, Func&& func)
+    : completion_handler_erasure_base<Return(Args...), Executor>(
+        std::move(exec)), func(std::move(func))
+  {
+  }
+
+  virtual Return call(Args ...args) override
+  {
+    std::move(func)(std::move(args)...);
+  }
+
+  Func func;
+};
+
+template<typename Signature, typename Executor = any_io_executor>
+struct completion_handler_erasure;
+
+template<typename Return,  typename ... Args, typename Executor>
+struct completion_handler_erasure<Return(Args...), Executor>
+{
+  struct deleter_t
+  {
+    using allocator_base = typename associated_allocator<Executor>::type;
+    using allocator_type =
+      typename std::allocator_traits<allocator_base>::template rebind_alloc<
+        completion_handler_erasure_base<Return(Args...), Executor>>;
+
+    allocator_type allocator;
+    std::size_t size;
+
+    template<typename Func>
+    static std::unique_ptr<
+        completion_handler_erasure_base<Return(Args...), Executor>, deleter_t>
+    make(Executor exec, Func&& func)
+    {
+      using type = completion_handler_erasure_impl<
+          std::remove_reference_t<Func>, Return(Args...), Executor>;
+      using alloc_type =  typename std::allocator_traits<
+          allocator_base>::template rebind_alloc<type>;
+      auto alloc = alloc_type(get_associated_allocator(exec));
+      auto size = sizeof(type);
+      auto p = std::allocator_traits<alloc_type>::allocate(alloc, size);
+      auto res = std::unique_ptr<type, deleter_t>(
+          p, deleter_t{allocator_type(alloc), size});
+      std::allocator_traits<alloc_type>::construct(alloc,
+          p, std::move(exec), std::forward<Func>(func));
+      return res;
+    }
+
+    void operator()(
+        completion_handler_erasure_base<Return(Args...), Executor> * p)
+    {
+      std::allocator_traits<allocator_type>::destroy(allocator, p);
+      std::allocator_traits<allocator_type>::deallocate(allocator, p, size);
+    }
+  };
+
+  completion_handler_erasure(const completion_handler_erasure&) = delete;
+  completion_handler_erasure(completion_handler_erasure&&) = default;
+  completion_handler_erasure& operator=(
+      const completion_handler_erasure&) = delete;
+  completion_handler_erasure& operator=(
+      completion_handler_erasure&&) = default;
+
+  constexpr completion_handler_erasure() = default;
+
+  constexpr completion_handler_erasure(nullptr_t)
+    : completion_handler_erasure()
+  {
+  }
+
+  template<typename Func>
+  completion_handler_erasure(Executor exec, Func&& func)
+    : impl_(deleter_t::make(std::move(exec), std::forward<Func>(func)))
+  {
+  }
+
+  ~completion_handler_erasure()
+  {
+    if (auto f = std::exchange(impl_, nullptr); f != nullptr)
+    {
+      boost::asio::dispatch(f->executor,
+          [f = std::move(f)]() mutable
+          {
+            std::move(f)->call(Args{}...);
+          });
+    }
+  }
+
+  Return operator()(Args ... args)
+  {
+    if (auto f = std::exchange(impl_, nullptr); f != nullptr)
+      f->call(std::move(args)...);
+  }
+
+  constexpr bool operator==(nullptr_t) const noexcept {return impl_ == nullptr;}
+  constexpr bool operator!=(nullptr_t) const noexcept {return impl_ != nullptr;}
+  constexpr bool operator!() const noexcept {return impl_ == nullptr;}
+
+private:
+  std::unique_ptr<
+    completion_handler_erasure_base<Return(Args...), Executor>, deleter_t>
+      impl_;
+};
+
+} // namespace detail
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#endif // BOOST_ASIO_EXPERIMENTAL_DETAIL_COMPLETION_HANDLER_ERASURE_HPP

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

@@ -0,0 +1,120 @@
+//
+// experimental/detail/coro_promise_allocator.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021 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_DETAIL_CORO_PROMISE_ALLOCATOR_HPP
+#define BOOST_ASIO_EXPERIMENTAL_DETAIL_CORO_PROMISE_ALLOCATOR_HPP
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/experimental/detail/coro_traits.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+template <typename Coroutine,
+     typename Executor = typename Coroutine::executor_type,
+     typename Allocator = typename std::allocator_traits<
+       associated_allocator_t<Executor>>:: template rebind_alloc<std::byte>,
+     bool Noexcept = noexcept(std::declval<Allocator>().allocate(0u))>
+struct coro_promise_allocator
+{
+  using allocator_type = Allocator;
+
+  template <typename... Args>
+  void* operator new(const std::size_t size, Executor executor, Args&&...)
+  {
+    static_assert(std::is_nothrow_move_constructible_v<allocator_type>);
+    allocator_type alloc{get_associated_allocator(executor)};
+
+    const auto csize = size + sizeof(alloc);
+    const auto raw =
+      std::allocator_traits<allocator_type>::allocate(alloc, csize);
+    new (raw) allocator_type(std::move(alloc));
+    return static_cast<std::byte*>(raw) + sizeof(alloc);
+  }
+
+  template <execution_context Context, typename... Args>
+  void* operator new(const std::size_t size, Context&& ctx, Args&&... args)
+  {
+    return coro_promise_allocator::operator new(size,
+        ctx.get_executor(), std::forward<Args>(args)...);
+  }
+
+  void operator delete(void* raw, std::size_t size )
+  {
+    auto * alloc_p = static_cast<allocator_type*>(raw);
+
+    auto alloc = std::move(*alloc_p);
+    alloc_p->~allocator_type();
+    std::allocator_traits<allocator_type>::deallocate(alloc,
+        static_cast<std::byte*>(raw), size + sizeof(allocator_type));
+  }
+};
+
+template <typename Coroutine, typename Executor>
+struct coro_promise_allocator<Coroutine,
+    Executor, std::allocator<std::byte>, false>
+{
+
+};
+
+template <typename Coroutine, typename Executor, typename Allocator>
+struct coro_promise_allocator<Coroutine, Executor, Allocator, true>
+{
+  using allocator_type = Allocator;
+
+  template <typename... Args>
+  void* operator new(const std::size_t size,
+      Executor executor, Args&&...) noexcept
+  {
+    static_assert(std::is_nothrow_move_constructible_v<allocator_type>);
+    allocator_type alloc{get_associated_allocator(executor)};
+
+    const auto csize = size + sizeof(alloc);
+    const auto raw =
+      std::allocator_traits<allocator_type>::allocate(alloc, csize);
+    if (raw == nullptr)
+      return nullptr;
+    new (raw) allocator_type(std::move(alloc));
+    return static_cast<std::byte*>(raw) + sizeof(alloc);
+  }
+
+  template <execution_context Context, typename... Args>
+  void* operator new(const std::size_t size,
+      Context&& ctx, Args&&... args) noexcept
+  {
+    return coro_promise_allocator::operator new(size,
+        ctx.get_executor(), std::forward<Args>(args)...);
+  }
+
+  void operator delete(void* raw, std::size_t size) noexcept
+  {
+    auto * alloc_p = static_cast<allocator_type*>(raw);
+    auto alloc = std::move(*alloc_p);
+    alloc_p->~allocator_type();
+    const auto csize = size + sizeof(allocator_type);
+    std::allocator_traits<allocator_type>::deallocate(alloc,
+        static_cast<std::byte*>(raw) - sizeof(allocator_type), csize);
+  }
+
+  static auto get_return_object_on_allocation_failure() noexcept -> Coroutine
+  {
+    return Coroutine{};
+  }
+};
+
+} // namespace detail
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#endif // BOOST_ASIO_EXPERIMENTAL_DETAIL_CORO_PROMISE_ALLOCATOR_HPP

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

@@ -0,0 +1,185 @@
+//
+// experimental/detail/coro_traits.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021 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_DETAIL_CORO_TRAITS_HPP
+#define BOOST_ASIO_EXPERIMENTAL_DETAIL_CORO_TRAITS_HPP
+
+#include <boost/asio/detail/config.hpp>
+#include <optional>
+#include <variant>
+#include <boost/asio/any_io_executor.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+template <class From, class To>
+concept convertible_to = std::is_convertible_v<From, To> &&
+  requires(std::add_rvalue_reference_t<From> (&f)()) {static_cast<To>(f()); };
+
+template <typename T>
+concept decays_to_executor = execution::executor<std::decay_t<T>>;
+
+template <typename T>
+concept execution_context = requires (T& t)
+{
+  {t.get_executor()} -> decays_to_executor;
+};
+
+template <typename Yield, typename Return>
+struct coro_result
+{
+  using type = std::variant<Yield, Return>;
+};
+
+template <typename Yield>
+struct coro_result<Yield, void>
+{
+  using type = std::optional<Yield>;
+};
+
+template <typename Return>
+struct coro_result<void, Return>
+{
+  using type = Return;
+};
+
+template <typename YieldReturn>
+struct coro_result<YieldReturn, YieldReturn>
+{
+  using type = YieldReturn;
+};
+
+template <>
+struct coro_result<void, void>
+{
+  using type = void;
+};
+
+template <typename Yield, typename Return>
+using coro_result_t = typename coro_result<Yield, Return>::type;
+
+template <typename Result, bool IsNoexcept>
+struct coro_handler;
+
+template <>
+struct coro_handler<void, false>
+{
+  using type = void(std::exception_ptr);
+};
+
+template <>
+struct coro_handler<void, true>
+{
+  using type = void();
+};
+
+template <typename T>
+struct coro_handler<T, false>
+{
+  using type = void(std::exception_ptr, T);
+};
+
+template <typename T>
+struct coro_handler<T, true>
+{
+  using type = void(T);
+};
+
+template <typename Result, bool IsNoexcept>
+using coro_handler_t = typename coro_handler<Result, IsNoexcept>::type;
+
+template <typename Yield, typename Return, typename Executor>
+struct coro_traits
+{
+  using input_type  = void;
+  using yield_type  = Yield;
+  using return_type = Return;
+  using result_type = coro_result_t<yield_type, return_type>;
+  using signature_type = result_type();
+  constexpr static bool is_noexcept = false;
+  using error_type = std::conditional_t<is_noexcept, void, std::exception_ptr>;
+  using completion_handler = coro_handler_t<result_type, is_noexcept>;
+};
+
+template <typename T, typename Return, typename Executor>
+struct coro_traits<T(), Return, Executor>
+{
+  using input_type = void;
+  using yield_type = T;
+  using return_type = Return;
+  using result_type = coro_result_t<yield_type, return_type>;
+  using signature_type = result_type();
+  constexpr static bool is_noexcept = false;
+  using error_type = std::conditional_t<is_noexcept, void, std::exception_ptr>;
+  using completion_handler = coro_handler_t<result_type, is_noexcept>;
+};
+
+template <typename T, typename Return, typename Executor>
+struct coro_traits<T() noexcept, Return, Executor>
+{
+  using input_type = void;
+  using yield_type = T;
+  using return_type = Return;
+  using result_type = coro_result_t<yield_type, return_type>;
+  using signature_type = result_type();
+  constexpr static bool is_noexcept = true;
+  using error_type = std::conditional_t<is_noexcept, void, std::exception_ptr>;
+  using completion_handler = coro_handler_t<result_type, is_noexcept>;
+};
+
+template <typename T, typename U, typename Return, typename Executor>
+struct coro_traits<T(U), Return, Executor>
+{
+  using input_type = U;
+  using yield_type = T;
+  using return_type = Return;
+  using result_type = coro_result_t<yield_type, return_type>;
+  using signature_type = result_type(input_type);
+  constexpr static bool is_noexcept = false;
+  using error_type = std::conditional_t<is_noexcept, void, std::exception_ptr>;
+  using completion_handler = coro_handler_t<result_type, is_noexcept>;
+};
+
+template <typename T, typename U, typename Return, typename Executor>
+struct coro_traits<T(U) noexcept, Return, Executor>
+{
+  using input_type = U;
+  using yield_type = T;
+  using return_type = Return;
+  using result_type = coro_result_t<yield_type, return_type>;
+  using signature_type = result_type(input_type);
+  constexpr static bool is_noexcept = true;
+  using error_type = std::conditional_t<is_noexcept, void, std::exception_ptr>;
+  using completion_handler = coro_handler_t<result_type, is_noexcept>;
+};
+
+
+template <typename Executor>
+struct coro_traits<void() noexcept, void, Executor>
+{
+  using input_type = void;
+  using yield_type = void;
+  using return_type = void;
+  using result_type = coro_result_t<yield_type, return_type>;
+  using signature_type = result_type(input_type);
+  constexpr static bool is_noexcept = true;
+  using error_type = std::conditional_t<is_noexcept, void, std::exception_ptr>;
+  using completion_handler = coro_handler_t<result_type, is_noexcept>;
+};
+
+} // namespace detail
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#endif // BOOST_ASIO_EXPERIMENTAL_DETAIL_CORO_TRAITS_HPP

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

@@ -0,0 +1,181 @@
+//
+// experimental/detail/partial_promise.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021 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_DETAIL_PARTIAL_PROMISE_HPP
+#define BOOST_ASIO_EXPERIMENTAL_DETAIL_PARTIAL_PROMISE_HPP
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/experimental/detail/coro_traits.hpp>
+#include <boost/asio/awaitable.hpp>
+#include <iostream>
+
+#if defined(BOOST_ASIO_HAS_STD_COROUTINE)
+# include <coroutine>
+#else // defined(BOOST_ASIO_HAS_STD_COROUTINE)
+# include <experimental/coroutine>
+#endif // defined(BOOST_ASIO_HAS_STD_COROUTINE)
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+#if defined(BOOST_ASIO_HAS_STD_COROUTINE)
+
+using std::coroutine_handle;
+using std::coroutine_traits;
+using std::suspend_never;
+using std::suspend_always;
+using std::noop_coroutine;
+
+#else // defined(BOOST_ASIO_HAS_STD_COROUTINE)
+
+using std::experimental::coroutine_handle;
+using std::experimental::coroutine_traits;
+using std::experimental::suspend_never;
+using std::experimental::suspend_always;
+using std::experimental::noop_coroutine;
+
+#endif // defined(BOOST_ASIO_HAS_STD_COROUTINE)
+
+struct partial_promise
+{
+  auto initial_suspend() noexcept
+  {
+    return boost::asio::detail::suspend_always{};
+  }
+
+  auto final_suspend() noexcept
+  {
+    struct awaitable_t
+    {
+      partial_promise *p;
+
+      constexpr bool await_ready() noexcept { return true; }
+
+      auto await_suspend(boost::asio::detail::coroutine_handle<>) noexcept
+      {
+        p->get_return_object().destroy();
+      }
+
+      constexpr void await_resume() noexcept {}
+    };
+
+    return awaitable_t{this};
+  }
+
+  void return_void() {}
+
+  coroutine_handle<partial_promise> get_return_object()
+  {
+    return coroutine_handle<partial_promise>::from_promise(*this);
+  }
+
+  void unhandled_exception()
+  {
+    assert(false);
+  }
+};
+
+} // namespace detail
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#if defined(BOOST_ASIO_HAS_STD_COROUTINE)
+
+namespace std {
+
+template<typename ... Args>
+struct coroutine_traits<
+    coroutine_handle<boost::asio::experimental::detail::partial_promise>,
+    Args...>
+{
+  using promise_type = boost::asio::experimental::detail::partial_promise;
+};
+
+} // namespace std
+
+#else // defined(BOOST_ASIO_HAS_STD_COROUTINE)
+
+namespace std { namespace experimental {
+
+template<typename... Args>
+struct coroutine_traits<
+    coroutine_handle<boost::asio::experimental::detail::partial_promise>,
+    Args...>
+{
+  using promise_type = boost::asio::experimental::detail::partial_promise;
+};
+
+}} // namespace std::experimental
+
+#endif // defined(BOOST_ASIO_HAS_STD_COROUTINE)
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+template<typename CompletionToken>
+auto post_coroutine(CompletionToken token) noexcept
+  -> coroutine_handle<partial_promise>
+{
+  post(std::move(token));
+  co_return;
+}
+
+template<execution::executor Executor, typename CompletionToken>
+auto post_coroutine(Executor exec, CompletionToken token) noexcept
+  -> coroutine_handle<partial_promise>
+{
+  post(exec, std::move(token));
+  co_return;
+}
+
+template<execution_context Context, typename CompletionToken>
+auto post_coroutine(Context &ctx, CompletionToken token) noexcept
+  -> coroutine_handle<partial_promise>
+{
+  post(ctx, std::move(token));
+  co_return;
+}
+
+template<typename CompletionToken>
+auto dispatch_coroutine(CompletionToken token) noexcept
+  -> coroutine_handle<partial_promise>
+{
+  dispatch(std::move(token));
+  co_return;
+}
+
+template<execution::executor Executor, typename CompletionToken>
+auto dispatch_coroutine(Executor exec, CompletionToken token) noexcept
+  -> coroutine_handle<partial_promise>
+{
+  dispatch(exec, std::move(token));
+  co_return;
+}
+
+template<execution_context Context, typename CompletionToken>
+auto dispatch_coroutine(Context &ctx, CompletionToken token) noexcept
+  -> coroutine_handle<partial_promise>
+{
+  dispatch(ctx, std::move(token));
+  co_return;
+}
+
+} // namespace detail
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#endif // BOOST_ASIO_EXPERIMENTAL_DETAIL_PARTIAL_PROMISE_HPP