passenger 6.0.16 → 6.0.17

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

@@ -290,7 +290,7 @@ public:
   }
 
   /// Get the executor associated with the object.
-  executor_type get_executor() BOOST_ASIO_NOEXCEPT
+  const executor_type& get_executor() BOOST_ASIO_NOEXCEPT
   {
     return executor_;
   }
@@ -427,7 +427,7 @@ private:
     {
     }
 
-    executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
     {
       return self_->get_executor();
     }
@@ -456,7 +456,7 @@ private:
     {
     }
 
-    executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+    const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
     {
       return self_->get_executor();
     }

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

@@ -82,6 +82,40 @@ struct channel_traits
   };
 };
 
+template <typename R>
+struct channel_traits<R(boost::system::error_code)>
+{
+  template <typename... NewSignatures>
+  struct rebind
+  {
+    typedef channel_traits<NewSignatures...> other;
+  };
+
+  template <typename Element>
+  struct container
+  {
+    typedef std::deque<Element> type;
+  };
+
+  typedef R receive_cancelled_signature(boost::system::error_code);
+
+  template <typename F>
+  static void invoke_receive_cancelled(F f)
+  {
+    const boost::system::error_code e = error::channel_cancelled;
+    BOOST_ASIO_MOVE_OR_LVALUE(F)(f)(e);
+  }
+
+  typedef R receive_closed_signature(boost::system::error_code);
+
+  template <typename F>
+  static void invoke_receive_closed(F f)
+  {
+    const boost::system::error_code e = error::channel_closed;
+    BOOST_ASIO_MOVE_OR_LVALUE(F)(f)(e);
+  }
+};
+
 template <typename R, typename... Args, typename... Signatures>
 struct channel_traits<R(boost::system::error_code, Args...), Signatures...>
 {
@@ -116,6 +150,42 @@ struct channel_traits<R(boost::system::error_code, Args...), Signatures...>
   }
 };
 
+template <typename R>
+struct channel_traits<R(std::exception_ptr)>
+{
+  template <typename... NewSignatures>
+  struct rebind
+  {
+    typedef channel_traits<NewSignatures...> other;
+  };
+
+  template <typename Element>
+  struct container
+  {
+    typedef std::deque<Element> type;
+  };
+
+  typedef R receive_cancelled_signature(std::exception_ptr);
+
+  template <typename F>
+  static void invoke_receive_cancelled(F f)
+  {
+    const boost::system::error_code e = error::channel_cancelled;
+    BOOST_ASIO_MOVE_OR_LVALUE(F)(f)(
+        std::make_exception_ptr(boost::system::system_error(e)));
+  }
+
+  typedef R receive_closed_signature(std::exception_ptr);
+
+  template <typename F>
+  static void invoke_receive_closed(F f)
+  {
+    const boost::system::error_code e = error::channel_closed;
+    BOOST_ASIO_MOVE_OR_LVALUE(F)(f)(
+        std::make_exception_ptr(boost::system::system_error(e)));
+  }
+};
+
 template <typename R, typename... Args, typename... Signatures>
 struct channel_traits<R(std::exception_ptr, Args...), Signatures...>
 {

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

@@ -0,0 +1,146 @@
+//
+// experimental/co_composed.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// 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)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_CO_COMPOSED_HPP
+#define BOOST_ASIO_EXPERIMENTAL_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>
+#include <boost/asio/async_result.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+
+/// Creates an initiation function object that may be used to launch a
+/// coroutine-based composed asynchronous operation.
+/**
+ * The experimental::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, per-operation cancellation is disabled for composed operations
+ * that use experimental::co_composed. It must be explicitly enabled by calling
+ * 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::experimental::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),
+ *                 boost::asio::as_tuple(boost::asio::deferred));
+ *
+ *             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),
+ *                 boost::asio::as_tuple(boost::asio::deferred));
+ *
+ *             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::experimental::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), boost::asio::deferred);
+ *
+ *                 co_await boost::asio::async_write(socket,
+ *                     boost::asio::buffer(data, n), boost::asio::deferred);
+ *               }
+ *             }
+ *             catch (const std::system_error& e)
+ *             {
+ *               co_return {e.code()};
+ *             }
+ *           }, socket),
+ *       token, std::ref(socket));
+ * } @endcode
+ */
+template <completion_signature... Signatures,
+    typename Implementation, typename... IoObjectsOrExecutors>
+auto co_composed(Implementation&& implementation,
+    IoObjectsOrExecutors&&... io_objects_or_executors);
+
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/experimental/impl/co_composed.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_CO_COMPOSED_HPP

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

@@ -23,7 +23,6 @@
 #include <boost/asio/experimental/coro_traits.hpp>
 #include <boost/asio/experimental/detail/coro_promise_allocator.hpp>
 #include <boost/asio/experimental/detail/partial_promise.hpp>
-#include <boost/asio/experimental/use_coro.hpp>
 #include <boost/asio/post.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -33,6 +32,10 @@ namespace asio {
 namespace experimental {
 namespace detail {
 
+template <typename Signature, typename Return,
+    typename Executor, typename Allocator>
+struct coro_promise;
+
 template <typename T, typename Coroutine>
 struct coro_with_arg;
 
@@ -45,7 +48,8 @@ struct coro_with_arg;
  * the underlying executor type.
  */
 template <typename Yield = void, typename Return = void,
-    typename Executor = any_io_executor>
+    typename Executor = any_io_executor,
+    typename Allocator = std::allocator<void>>
 struct coro
 {
   /// The traits of the coroutine. See boost::asio::experimental::coro_traits
@@ -79,7 +83,7 @@ struct coro
   using completion_handler = typename traits::completion_handler;
 
   /// The internal promise-type of the coroutine.
-  using promise_type = detail::coro_promise<Yield, Return, Executor>;
+  using promise_type = detail::coro_promise<Yield, Return, Executor, Allocator>;
 
 #if !defined(GENERATING_DOCUMENTATION)
   template <typename T, typename Coroutine>
@@ -89,8 +93,11 @@ struct coro
   /// The executor type.
   using executor_type = Executor;
 
+  /// The allocator type.
+  using allocator_type = Allocator;
+
 #if !defined(GENERATING_DOCUMENTATION)
-  friend struct detail::coro_promise<Yield, Return, Executor>;
+  friend struct detail::coro_promise<Yield, Return, Executor, Allocator>;
 #endif // !defined(GENERATING_DOCUMENTATION)
 
   /// The default constructor, gives an invalid coroutine.
@@ -102,7 +109,7 @@ struct coro
   {
   }
 
-  coro(const coro &) = delete;
+  coro(const coro&) = delete;
 
   /// Move assignment.
   coro& operator=(coro&& lhs) noexcept
@@ -166,6 +173,19 @@ struct coro
       throw std::logic_error("Coroutine has no executor");
   }
 
+  /// Get the used allocator.
+  allocator_type get_allocator() const
+  {
+    if (coro_)
+      return coro_->get_allocator();
+
+    if constexpr (std::is_default_constructible_v<Allocator>)
+      return Allocator{};
+    else
+      throw std::logic_error(
+          "Coroutine has no available allocator without a constructed promise");
+  }
+
   /// Resume the coroutine.
   /**
    * @param token The completion token of the async resume.
@@ -254,6 +274,16 @@ private:
   promise_type* coro_{nullptr};
 };
 
+/// A generator is a coro that returns void and yields value.
+template<typename T, typename Executor = boost::asio::any_io_executor,
+    typename Allocator = std::allocator<void>>
+using generator = coro<T, void, Executor, Allocator>;
+
+/// A task is a coro that does not yield values
+template<typename T, typename Executor = boost::asio::any_io_executor,
+    typename Allocator = std::allocator<void>>
+using task = coro<void(), T, Executor, Allocator>;
+
 } // namespace experimental
 } // namespace asio
 } // namespace boost

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

@@ -56,9 +56,19 @@ struct associator<Associator,
     DefaultCandidate>
   : Associator<Handler, DefaultCandidate>
 {
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const experimental::detail::channel_handler<Payload, Handler>& h,
-      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const experimental::detail::channel_handler<Payload, Handler>& h)
+    BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const experimental::detail::channel_handler<Payload, Handler>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
   {
     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }

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

@@ -94,11 +94,18 @@ public:
     typename associated_allocator<Handler>::type allocator =
       (get_associated_allocator)(handler);
 
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+    boost::asio::prefer(
+        boost::asio::require(executor_, execution::blocking.never),
+        execution::allocator(allocator)
+      ).execute(BOOST_ASIO_MOVE_CAST(Function)(function));
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
     execution::execute(
         boost::asio::prefer(
           boost::asio::require(executor_, execution::blocking.never),
           execution::allocator(allocator)),
         BOOST_ASIO_MOVE_CAST(Function)(function));
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
   }
 
 private:

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

@@ -487,6 +487,186 @@ private:
   std::size_t buffer_;
 };
 
+// The implementation for an error_code signature.
+template <typename Mutex>
+template <typename Traits, typename R>
+struct channel_service<Mutex>::implementation_type<
+    Traits, R(boost::system::error_code)>
+  : channel_service::base_implementation_type
+{
+  // The traits type associated with the channel.
+  typedef typename Traits::template rebind<R(boost::system::error_code)>::other
+    traits_type;
+
+  // Type of an element stored in the buffer.
+  typedef typename conditional<
+      has_signature<
+        typename traits_type::receive_cancelled_signature,
+        R(boost::system::error_code)
+      >::value,
+      typename conditional<
+        has_signature<
+          typename traits_type::receive_closed_signature,
+          R(boost::system::error_code)
+        >::value,
+        channel_payload<R(boost::system::error_code)>,
+        channel_payload<
+          R(boost::system::error_code),
+          typename traits_type::receive_closed_signature
+        >
+      >::type,
+      typename conditional<
+        has_signature<
+          typename traits_type::receive_closed_signature,
+          R(boost::system::error_code),
+          typename traits_type::receive_cancelled_signature
+        >::value,
+        channel_payload<
+          R(boost::system::error_code),
+          typename traits_type::receive_cancelled_signature
+        >,
+        channel_payload<
+          R(boost::system::error_code),
+          typename traits_type::receive_cancelled_signature,
+          typename traits_type::receive_closed_signature
+        >
+      >::type
+    >::type payload_type;
+
+  // Construct with empty buffer.
+  implementation_type()
+    : size_(0)
+  {
+  }
+
+  // Move from another buffer.
+  void buffer_move_from(implementation_type& other)
+  {
+    size_ = other.buffer_;
+    other.size_ = 0;
+    first_ = other.first_;
+    other.first.count_ = 0;
+    rest_ = BOOST_ASIO_MOVE_CAST(
+        typename traits_type::template container<
+          buffered_value>::type)(other.rest_);
+    other.buffer_clear();
+  }
+
+  // Get number of buffered elements.
+  std::size_t buffer_size() const
+  {
+    return size_;
+  }
+
+  // Push a new value to the back of the buffer.
+  void buffer_push(payload_type payload)
+  {
+    buffered_value& last = rest_.empty() ? first_ : rest_.back();
+    if (last.count_ == 0)
+    {
+      value_handler handler{last.value_};
+      payload.receive(handler);
+      last.count_ = 1;
+    }
+    else
+    {
+      boost::system::error_code value{last.value_};
+      value_handler handler{value};
+      payload.receive(handler);
+      if (last.value_ == value)
+        ++last.count_;
+      else
+        rest_.push_back({value, 1});
+    }
+    ++size_;
+  }
+
+  // Push new values to the back of the buffer.
+  std::size_t buffer_push_n(std::size_t count, payload_type payload)
+  {
+    std::size_t available = this->max_buffer_size_ - size_;
+    count = (count < available) ? count : available;
+    if (count > 0)
+    {
+      buffered_value& last = rest_.empty() ? first_ : rest_.back();
+      if (last.count_ == 0)
+      {
+        payload.receive(value_handler{last.value_});
+        last.count_ = count;
+      }
+      else
+      {
+        boost::system::error_code value{last.value_};
+        payload.receive(value_handler{value});
+        if (last.value_ == value)
+          last.count_ += count;
+        else
+          rest_.push_back({value, count});
+      }
+      size_ += count;
+    }
+    return count;
+  }
+
+  // Get the element at the front of the buffer.
+  payload_type buffer_front()
+  {
+    return payload_type({0, first_.value_});
+  }
+
+  // Pop a value from the front of the buffer.
+  void buffer_pop()
+  {
+    --size_;
+    if (--first_.count_ == 0 && !rest_.empty())
+    {
+      first_ = rest_.front();
+      rest_.pop_front();
+    }
+  }
+
+  // Clear all values from the buffer.
+  void buffer_clear()
+  {
+    size_ = 0;
+    first_.count_ == 0;
+    rest_.clear();
+  }
+
+private:
+  struct buffered_value
+  {
+    boost::system::error_code value_;
+    std::size_t count_ = 0;
+  };
+
+  struct value_handler
+  {
+    boost::system::error_code& target_;
+
+    template <typename... Args>
+    void operator()(const boost::system::error_code& value, Args&&...)
+    {
+      target_ = value;
+    }
+  };
+
+  buffered_value& last_value()
+  {
+    return rest_.empty() ? first_ : rest_.back();
+  }
+
+  // Total number of buffered values.
+  std::size_t size_;
+
+  // The first buffered value is maintained as a separate data member to avoid
+  // allocating space in the container in the common case.
+  buffered_value first_;
+
+  // The rest of the buffered values.
+  typename traits_type::template container<buffered_value>::type rest_;
+};
+
 } // namespace detail
 } // namespace experimental
 } // namespace asio