passenger 6.0.16 → 6.0.18

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

@@ -16,7 +16,9 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+#include <vector>
 #include <boost/asio/detail/array.hpp>
+#include <boost/asio/detail/memory.hpp>
 #include <boost/asio/detail/utility.hpp>
 #include <boost/asio/experimental/cancellation_condition.hpp>
 
@@ -79,8 +81,57 @@ template <typename Condition, typename Handler,
 void parallel_group_launch(Condition cancellation_condition, Handler handler,
     std::tuple<Ops...>& ops, boost::asio::detail::index_sequence<I...>);
 
+// Helper trait for determining ranged parallel group completion signatures.
+
+template <typename Signature, typename Allocator>
+struct ranged_parallel_group_signature;
+
+template <typename R, typename... Args, typename Allocator>
+struct ranged_parallel_group_signature<R(Args...), Allocator>
+{
+  typedef std::vector<std::size_t,
+    BOOST_ASIO_REBIND_ALLOC(Allocator, std::size_t)> order_type;
+  typedef R raw_type(
+      std::vector<Args, BOOST_ASIO_REBIND_ALLOC(Allocator, Args)>...);
+  typedef R type(order_type,
+      std::vector<Args, BOOST_ASIO_REBIND_ALLOC(Allocator, Args)>...);
+};
+
+template <typename Condition, typename Handler,
+    typename Range, typename Allocator>
+void ranged_parallel_group_launch(Condition cancellation_condition,
+    Handler handler, Range&& range, const Allocator& allocator);
+
+char (&parallel_group_has_iterator_helper(...))[2];
+
+template <typename T>
+char parallel_group_has_iterator_helper(T*, typename T::iterator* = 0);
+
+template <typename T>
+struct parallel_group_has_iterator_typedef
+{
+  enum { value = (sizeof((parallel_group_has_iterator_helper)((T*)(0))) == 1) };
+};
+
 } // namespace detail
 
+/// Type trait used to determine whether a type is a range of asynchronous
+/// operations that can be used with with @c make_parallel_group.
+template <typename T>
+struct is_async_operation_range
+{
+#if defined(GENERATING_DOCUMENTATION)
+  /// The value member is true if the type may be used as a range of
+  /// asynchronous operations.
+  static const bool value;
+#else
+  enum
+  {
+    value = detail::parallel_group_has_iterator_typedef<T>::value
+  };
+#endif
+};
+
 /// A group of asynchronous operations that may be launched in parallel.
 /**
  * See the documentation for boost::asio::experimental::make_parallel_group for
@@ -196,6 +247,211 @@ make_parallel_group(Ops... ops)
   return parallel_group<Ops...>(std::move(ops)...);
 }
 
+/// A range-based group of asynchronous operations that may be launched in
+/// parallel.
+/**
+ * See the documentation for boost::asio::experimental::make_parallel_group for
+ * a usage example.
+ */
+template <typename Range, typename Allocator = std::allocator<void> >
+class ranged_parallel_group
+{
+private:
+  struct initiate_async_wait
+  {
+    template <typename Handler, typename Condition>
+    void operator()(Handler&& h, Condition&& c,
+        Range&& range, const Allocator& allocator) const
+    {
+      detail::ranged_parallel_group_launch(std::move(c),
+          std::move(h), std::forward<Range>(range), allocator);
+    }
+  };
+
+  Range range_;
+  Allocator allocator_;
+
+public:
+  /// Constructor.
+  explicit ranged_parallel_group(Range range,
+      const Allocator& allocator = Allocator())
+    : range_(std::move(range)),
+      allocator_(allocator)
+  {
+  }
+
+  /// The completion signature for the group of operations.
+  typedef typename detail::ranged_parallel_group_signature<
+      typename completion_signature_of<
+        typename std::decay<
+          decltype(*std::declval<typename Range::iterator>())>::type>::type,
+      Allocator>::type signature;
+
+  /// Initiate an asynchronous wait for the group of operations.
+  /**
+   * Launches the group and asynchronously waits for completion.
+   *
+   * @param cancellation_condition A function object, called on completion of
+   * an operation within the group, that is used to determine whether to cancel
+   * the remaining operations. The function object is passed the arguments of
+   * the completed operation's handler. To trigger cancellation of the remaining
+   * operations, it must return a boost::asio::cancellation_type value other
+   * than <tt>boost::asio::cancellation_type::none</tt>.
+   *
+   * @param token A @ref completion_token whose signature is comprised of
+   * a @c std::vector<std::size_t, Allocator> indicating the completion order of
+   * the operations, followed by a vector for each of the completion signature's
+   * arguments.
+   *
+   * The library provides the following @c cancellation_condition types:
+   *
+   * @li boost::asio::experimental::wait_for_all
+   * @li boost::asio::experimental::wait_for_one
+   * @li boost::asio::experimental::wait_for_one_error
+   * @li boost::asio::experimental::wait_for_one_success
+   */
+  template <typename CancellationCondition,
+      BOOST_ASIO_COMPLETION_TOKEN_FOR(signature) CompletionToken>
+  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(range_), allocator_)))
+  {
+    return boost::asio::async_initiate<CompletionToken, signature>(
+        initiate_async_wait(), token,
+        std::move(cancellation_condition),
+        std::move(range_), allocator_);
+  }
+};
+
+/// Create a group of operations that may be launched in parallel.
+/**
+ * @param range A range containing the operations to be launched.
+ *
+ * For example:
+ * @code
+ * using op_type = decltype(
+ *     socket1.async_read_some(
+ *       boost::asio::buffer(data1),
+ *       boost::asio::deferred
+ *     )
+ *   );
+ *
+ * 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
+ *     )
+ *   );
+ *
+ * boost::asio::experimental::make_parallel_group(ops).async_wait(
+ *     boost::asio::experimental::wait_for_all(),
+ *     [](
+ *         std::vector<std::size_t> completion_order,
+ *         std::vector<boost::system::error_code> e,
+ *         std::vector<std::size_t> n
+ *       )
+ *     {
+ *       for (std::size_t i = 0; i < completion_order.size(); ++i)
+ *       {
+ *         std::size_t idx = completion_order[i];
+ *         std::cout << "socket " << idx << " finished: ";
+ *         std::cout << e[idx] << ", " << n[idx] << "\n";
+ *       }
+ *     }
+ *   );
+ * @endcode
+ */
+template <typename Range>
+BOOST_ASIO_NODISCARD inline
+ranged_parallel_group<typename std::decay<Range>::type>
+make_parallel_group(Range&& range,
+    typename constraint<
+      is_async_operation_range<typename std::decay<Range>::type>::value
+    >::type = 0)
+{
+  return ranged_parallel_group<typename std::decay<Range>::type>(
+      std::forward<Range>(range));
+}
+
+/// Create a group of operations that may be launched in parallel.
+/**
+ * @param allocator Specifies the allocator to be used with the result vectors.
+ *
+ * @param range A range containing the operations to be launched.
+ *
+ * For example:
+ * @code
+ * using op_type = decltype(
+ *     socket1.async_read_some(
+ *       boost::asio::buffer(data1),
+ *       boost::asio::deferred
+ *     )
+ *   );
+ *
+ * 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
+ *     )
+ *   );
+ *
+ * boost::asio::experimental::make_parallel_group(
+ *     std::allocator_arg_t,
+ *     my_allocator,
+ *     ops
+ *   ).async_wait(
+ *     boost::asio::experimental::wait_for_all(),
+ *     [](
+ *         std::vector<std::size_t> completion_order,
+ *         std::vector<boost::system::error_code> e,
+ *         std::vector<std::size_t> n
+ *       )
+ *     {
+ *       for (std::size_t i = 0; i < completion_order.size(); ++i)
+ *       {
+ *         std::size_t idx = completion_order[i];
+ *         std::cout << "socket " << idx << " finished: ";
+ *         std::cout << e[idx] << ", " << n[idx] << "\n";
+ *       }
+ *     }
+ *   );
+ * @endcode
+ */
+template <typename Allocator, typename Range>
+BOOST_ASIO_NODISCARD inline
+ranged_parallel_group<typename std::decay<Range>::type, Allocator>
+make_parallel_group(allocator_arg_t, const Allocator& allocator, Range&& range,
+    typename constraint<
+      is_async_operation_range<typename std::decay<Range>::type>::value
+    >::type = 0)
+{
+  return ranged_parallel_group<typename std::decay<Range>::type, Allocator>(
+      std::forward<Range>(range), allocator);
+}
+
 } // namespace experimental
 } // namespace asio
 } // namespace boost

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

@@ -20,14 +20,14 @@
 #include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/any_io_executor.hpp>
 #include <boost/asio/associated_cancellation_slot.hpp>
+#include <boost/asio/associated_executor.hpp>
 #include <boost/asio/bind_executor.hpp>
 #include <boost/asio/cancellation_signal.hpp>
-#include <boost/asio/experimental/detail/completion_handler_erasure.hpp>
+#include <boost/asio/dispatch.hpp>
 #include <boost/asio/experimental/impl/promise.hpp>
 #include <boost/asio/post.hpp>
 
 #include <algorithm>
-#include <variant>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -35,11 +35,6 @@ namespace boost {
 namespace asio {
 namespace experimental {
 
-template <typename Executor = any_io_executor>
-struct use_promise_t {};
-
-constexpr use_promise_t<> use_promise;
-
 template <typename T>
 struct is_promise : std::false_type {};
 
@@ -64,40 +59,49 @@ struct promise_value_type<T>
 template <>
 struct promise_value_type<>
 {
-  using type = std::monostate;
+  using type = std::tuple<>;
 };
 
 #if defined(GENERATING_DOCUMENTATION)
-/// The primary template is not defined.
-template<typename Signature = void(), typename Executor = any_io_executor>
+/// A disposable handle for an eager operation.
+/**
+ * @tparam Signature The signature of the operation.
+ *
+ * @tparam Executor The executor to be used by the promise (taken from the
+ * operation).
+ *
+ * @tparam Allocator The allocator used for the promise. Can be set through
+ * use_allocator.
+ *
+ * A promise can be used to initiate an asynchronous option that can be
+ * completed later. If the promise gets destroyed before completion, the
+ * operation gets a cancel signal and the result is ignored.
+ *
+ * A promise fulfills the requirements of async_operation.
+ *
+ * @par Examples
+ * Reading and writing from one coroutine.
+ * @code
+ * 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);
+ *   co_await p;
+ * }
+ * @endcode
+ */
+template<typename Signature = void(),
+    typename Executor = boost::asio::any_io_executor,
+    typename Allocator = std::allocator<void>>
 struct promise
-{
-};
+#else
+template <typename ... Ts, typename Executor, typename Allocator>
+struct promise<void(Ts...), Executor,  Allocator>
 #endif // defined(GENERATING_DOCUMENTATION)
-
-template <typename ... Ts, typename Executor>
-struct promise<void(Ts...), Executor>
 {
+  /// The value that's returned by the promise.
   using value_type = typename promise_value_type<Ts...>::type;
-  using tuple_type = std::tuple<Ts...>;
-  using executor_type = Executor;
-
-  /// Rebinds the promise type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The file type when rebound to the specified executor.
-    typedef promise<void(Ts...), Executor1> other;
-  };
-
-  /// Get the executor of the promise
-  executor_type get_executor() const
-  {
-    if (impl_)
-      return impl_->executor;
-    else
-      return {};
-  }
 
   /// Cancel the promise. Usually done through the destructor.
   void cancel(cancellation_type level = cancellation_type::all)
@@ -105,22 +109,20 @@ struct promise<void(Ts...), Executor>
     if (impl_ && !impl_->done)
     {
       boost::asio::dispatch(impl_->executor,
-          [level, impl = impl_]{impl->cancel.emit(level);});
+          [level, impl = impl_]{ impl->cancel.emit(level); });
     }
   }
 
   /// Check if the promise is completed already.
-  bool complete() const noexcept
+  bool completed() const noexcept
   {
     return impl_ && impl_->done;
   }
 
   /// Wait for the promise to become ready.
-  template <
-    BOOST_ASIO_COMPLETION_TOKEN_FOR(void(Ts...)) CompletionToken
-      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  auto async_wait(CompletionToken&& token
-      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+  template <BOOST_ASIO_COMPLETION_TOKEN_FOR(void(Ts...)) CompletionToken>
+  inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void(Ts...))
+  operator()(CompletionToken&& token)
   {
     assert(impl_);
 
@@ -132,37 +134,52 @@ struct promise<void(Ts...), Executor>
   promise(const promise& ) = delete;
   promise(promise&& ) noexcept = default;
 
+  /// Destruct the promise and cancel the operation.
+  /**
+   * It is safe to destruct a promise of a promise that didn't complete.
+   */
   ~promise() { cancel(); }
 
 
 private:
 #if !defined(GENERATING_DOCUMENTATION)
-  template <typename, typename> friend struct promise;
-  friend struct detail::promise_handler<void(Ts...)>;
+  template <typename, typename, typename> friend struct promise;
+  friend struct detail::promise_handler<void(Ts...), Executor, Allocator>;
 #endif // !defined(GENERATING_DOCUMENTATION)
 
-  std::shared_ptr<detail::promise_impl<void(Ts...), Executor>> impl_;
-  promise(std::shared_ptr<detail::promise_impl<void(Ts...), Executor>> impl)
+  std::shared_ptr<detail::promise_impl<
+    void(Ts...), Executor, Allocator>> impl_;
+
+  promise(
+      std::shared_ptr<detail::promise_impl<
+        void(Ts...), Executor, Allocator>> impl)
     : impl_(impl)
   {
   }
 
   struct initiate_async_wait
   {
-    std::shared_ptr<detail::promise_impl<void(Ts...), Executor>> self_;
+    std::shared_ptr<detail::promise_impl<
+      void(Ts...), Executor, Allocator>> self_;
 
     template <typename WaitHandler>
     void operator()(WaitHandler&& handler) const
     {
-      const auto exec = get_associated_executor(handler, self_->executor);
+      const auto alloc = get_associated_allocator(
+          handler, self_->get_allocator());
+
       auto cancel = get_associated_cancellation_slot(handler);
+
       if (self_->done)
       {
+        auto exec = boost::asio::get_associated_executor(
+            handler, self_->get_executor());
+
         boost::asio::post(exec,
-            [self = self_, h = std::forward<WaitHandler>(handler)]() mutable
+            [self = std::move(self_),
+              handler = std::forward<WaitHandler>(handler)]() mutable
             {
-              std::apply(std::forward<WaitHandler>(h),
-                  std::move(*self->result));
+              self->apply(std::move(handler));
             });
       }
       else
@@ -171,26 +188,29 @@ private:
         {
           struct cancel_handler
           {
-            std::weak_ptr<detail::promise_impl<void(Ts...), Executor>> self;
+            std::weak_ptr<detail::promise_impl<
+              void(Ts...), Executor, Allocator>> self;
 
             cancel_handler(
-                std::weak_ptr<detail::promise_impl<void(Ts...), Executor>> self)
+                std::weak_ptr<detail::promise_impl<
+                  void(Ts...), Executor, Allocator>> self)
               : self(std::move(self))
             {
             }
 
             void operator()(cancellation_type level) const
             {
-              if (auto p = self.lock(); p != nullptr)
+              if (auto p = self.lock())
+              {
                 p->cancel.emit(level);
-
+                p->cancel_();
+              }
             }
           };
-
           cancel.template emplace<cancel_handler>(self_);
         }
 
-        self_->completion = {exec, std::forward<WaitHandler>(handler)};
+        self_->set_completion(alloc, std::forward<WaitHandler>(handler));
       }
     }
   };
@@ -198,30 +218,6 @@ private:
 
 } // namespace experimental
 
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename Executor, typename R, typename... Args>
-struct async_result<experimental::use_promise_t<Executor>, R(Args...)>
-{
-  using handler_type = experimental::detail::promise_handler<
-    void(typename decay<Args>::type...), Executor>;
-
-  using return_type = experimental::promise<
-    void(typename decay<Args>::type...), Executor>;
-
-  template <typename Initiation, typename... InitArgs>
-  static auto initiate(Initiation initiation,
-      experimental::use_promise_t<Executor>, InitArgs... args)
-    -> typename handler_type::promise_type
-  {
-    handler_type ht{get_associated_executor(initiation)};
-    std::move(initiation)(ht, std::move(args)...);
-    return ht.make_promise();
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
 } // namespace asio
 } // namespace boost
 

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

@@ -17,11 +17,9 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <optional>
-#include <boost/asio/bind_cancellation_slot.hpp>
-#include <boost/asio/bind_executor.hpp>
-#include <boost/system/error_code.hpp>
-#include <boost/asio/experimental/detail/partial_promise.hpp>
+#include <memory>
+#include <boost/asio/deferred.hpp>
+#include <boost/asio/detail/source_location.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -32,8 +30,7 @@ class any_io_executor;
 
 namespace experimental {
 
-/// A @ref completion_token that represents the currently executing resumable
-/// coroutine.
+/// A @ref completion_token that creates another coro for the task completion.
 /**
  * The @c use_coro_t class, with its value @c use_coro, is used to represent an
  * operation that can be awaited by the current resumable coroutine. This
@@ -50,26 +47,36 @@ namespace experimental {
  * above example) suspends the current coroutine. The coroutine is resumed when
  * 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.
  */
-template <typename Executor = any_io_executor>
+template <typename Allocator = std::allocator<void>>
 struct use_coro_t
 {
+
+  /// The allocator type. The allocator is used when constructing the
+  /// @c std::promise object for a given asynchronous operation.
+  typedef Allocator allocator_type;
+
   /// Default constructor.
   BOOST_ASIO_CONSTEXPR use_coro_t(
+      allocator_type allocator = allocator_type{}
 #if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
 # if defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
-      boost::asio::detail::source_location location =
+      , boost::asio::detail::source_location location =
         boost::asio::detail::source_location::current()
 # endif // defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
 #endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
     )
+    : allocator_(allocator)
 #if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
 # if defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
-    : file_name_(location.file_name()),
+    , file_name_(location.file_name()),
       line_(location.line()),
       function_name_(location.function_name())
 # else // defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
-    : file_name_(0),
+    , file_name_(0),
       line_(0),
       function_name_(0)
 # endif // defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
@@ -77,14 +84,30 @@ struct use_coro_t
   {
   }
 
+
+  /// Specify an alternate allocator.
+  template <typename OtherAllocator>
+  use_coro_t<OtherAllocator> rebind(const OtherAllocator& allocator) const
+  {
+    return use_future_t<OtherAllocator>(allocator);
+  }
+
+  /// Obtain allocator.
+  allocator_type get_allocator() const
+  {
+    return allocator_;
+  }
+
   /// Constructor used to specify file name, line, and function name.
   BOOST_ASIO_CONSTEXPR use_coro_t(const char* file_name,
-      int line, const char* function_name)
+      int line, const char* function_name,
+      allocator_type allocator = allocator_type{}) :
 #if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
-    : file_name_(file_name),
+      file_name_(file_name),
       line_(line),
-      function_name_(function_name)
+      function_name_(function_name),
 #endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+      allocator_(allocator)
   {
 #if !defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
     (void)file_name;
@@ -144,6 +167,9 @@ struct use_coro_t
   int line_;
   const char* function_name_;
 #endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
+
+private:
+  Allocator allocator_;
 };
 
 /// A @ref completion_token object that represents the currently executing