passenger 6.0.19 → 6.0.21

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

@@ -2,7 +2,7 @@
 // experimental/detail/channel_operation.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2024 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)
@@ -18,7 +18,11 @@
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/associated_allocator.hpp>
 #include <boost/asio/associated_executor.hpp>
+#include <boost/asio/associated_immediate_executor.hpp>
+#include <boost/asio/detail/initiate_post.hpp>
+#include <boost/asio/detail/initiate_dispatch.hpp>
 #include <boost/asio/detail/op_queue.hpp>
+#include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/execution/executor.hpp>
 #include <boost/asio/execution/outstanding_work.hpp>
 #include <boost/asio/executor_work_guard.hpp>
@@ -36,7 +40,7 @@ namespace detail {
 class channel_operation BOOST_ASIO_INHERIT_TRACKED_HANDLER
 {
 public:
-  template <typename Executor, typename = void>
+  template <typename Executor, typename = void, typename = void>
   class handler_work_base;
 
   template <typename Handler, typename IoExecutor, typename = void>
@@ -51,9 +55,11 @@ protected:
   enum action
   {
     destroy_op = 0,
-    complete_op = 1,
-    cancel_op = 2,
-    close_op = 3
+    immediate_op = 1,
+    post_op = 2,
+    dispatch_op = 3,
+    cancel_op = 4,
+    close_op = 5
   };
 
   typedef void (*func_type)(channel_operation*, action, void*);
@@ -79,65 +85,142 @@ public:
   void* cancellation_key_;
 };
 
-template <typename Executor, typename>
+template <typename Executor, typename, typename>
 class channel_operation::handler_work_base
 {
 public:
+  typedef decay_t<
+      prefer_result_t<Executor,
+        execution::outstanding_work_t::tracked_t
+      >
+    > executor_type;
+
   handler_work_base(int, const Executor& ex)
     : executor_(boost::asio::prefer(ex, execution::outstanding_work.tracked))
   {
   }
 
+  const executor_type& get_executor() const noexcept
+  {
+    return executor_;
+  }
+
+  template <typename IoExecutor, typename Function, typename Handler>
+  void post(const IoExecutor& io_exec, Function& function, Handler&)
+  {
+    (boost::asio::detail::initiate_post_with_executor<IoExecutor>(io_exec))(
+        static_cast<Function&&>(function));
+  }
+
   template <typename Function, typename Handler>
-  void post(Function& function, Handler& handler)
+  void dispatch(Function& function, Handler& handler)
   {
-    typename associated_allocator<Handler>::type allocator =
+    associated_allocator_t<Handler> allocator =
+      (get_associated_allocator)(handler);
+
+    boost::asio::prefer(executor_,
+        execution::allocator(allocator)
+      ).execute(static_cast<Function&&>(function));
+  }
+
+private:
+  executor_type executor_;
+};
+
+template <typename Executor>
+class channel_operation::handler_work_base<Executor,
+    enable_if_t<
+      execution::is_executor<Executor>::value
+    >,
+    enable_if_t<
+      can_require<Executor, execution::blocking_t::never_t>::value
+    >
+  >
+{
+public:
+  typedef decay_t<
+      prefer_result_t<Executor,
+        execution::outstanding_work_t::tracked_t
+      >
+    > executor_type;
+
+  handler_work_base(int, const Executor& ex)
+    : executor_(boost::asio::prefer(ex, execution::outstanding_work.tracked))
+  {
+  }
+
+  const executor_type& get_executor() const noexcept
+  {
+    return executor_;
+  }
+
+  template <typename IoExecutor, typename Function, typename Handler>
+  void post(const IoExecutor&, Function& function, Handler& handler)
+  {
+    associated_allocator_t<Handler> 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)
+      ).execute(static_cast<Function&&>(function));
+  }
+
+  template <typename Function, typename Handler>
+  void dispatch(Function& function, Handler& handler)
+  {
+    associated_allocator_t<Handler> allocator =
+      (get_associated_allocator)(handler);
+
+    boost::asio::prefer(executor_,
+        execution::allocator(allocator)
+      ).execute(static_cast<Function&&>(function));
   }
 
 private:
-  typename decay<
-      typename prefer_result<Executor,
-        execution::outstanding_work_t::tracked_t
-      >::type
-    >::type executor_;
+  executor_type executor_;
 };
 
 #if !defined(BOOST_ASIO_NO_TS_EXECUTORS)
 
 template <typename Executor>
 class channel_operation::handler_work_base<Executor,
-    typename enable_if<
+    enable_if_t<
       !execution::is_executor<Executor>::value
-    >::type>
+    >
+  >
 {
 public:
+  typedef Executor executor_type;
+
   handler_work_base(int, const Executor& ex)
     : work_(ex)
   {
   }
 
-  template <typename Function, typename Handler>
-  void post(Function& function, Handler& handler)
+  executor_type get_executor() const noexcept
+  {
+    return work_.get_executor();
+  }
+
+  template <typename IoExecutor, typename Function, typename Handler>
+  void post(const IoExecutor&, Function& function, Handler& handler)
   {
-    typename associated_allocator<Handler>::type allocator =
+    associated_allocator_t<Handler> allocator =
       (get_associated_allocator)(handler);
 
     work_.get_executor().post(
-        BOOST_ASIO_MOVE_CAST(Function)(function), allocator);
+        static_cast<Function&&>(function), allocator);
+  }
+
+  template <typename Function, typename Handler>
+  void dispatch(Function& function, Handler& handler)
+  {
+    associated_allocator_t<Handler> allocator =
+      (get_associated_allocator)(handler);
+
+    work_.get_executor().dispatch(
+        static_cast<Function&&>(function), allocator);
   }
 
 private:
@@ -150,51 +233,123 @@ template <typename Handler, typename IoExecutor, typename>
 class channel_operation::handler_work :
   channel_operation::handler_work_base<IoExecutor>,
   channel_operation::handler_work_base<
-      typename associated_executor<Handler, IoExecutor>::type, IoExecutor>
+      associated_executor_t<Handler, IoExecutor>, IoExecutor>
 {
 public:
   typedef channel_operation::handler_work_base<IoExecutor> base1_type;
 
   typedef channel_operation::handler_work_base<
-      typename associated_executor<Handler, IoExecutor>::type, IoExecutor>
+      associated_executor_t<Handler, IoExecutor>, IoExecutor>
     base2_type;
 
-  handler_work(Handler& handler, const IoExecutor& io_ex) BOOST_ASIO_NOEXCEPT
+  handler_work(Handler& handler, const IoExecutor& io_ex) noexcept
     : base1_type(0, io_ex),
       base2_type(0, (get_associated_executor)(handler, io_ex))
   {
   }
 
   template <typename Function>
-  void complete(Function& function, Handler& handler)
+  void post(Function& function, Handler& handler)
+  {
+    base2_type::post(base1_type::get_executor(), function, handler);
+  }
+
+  template <typename Function>
+  void dispatch(Function& function, Handler& handler)
   {
-    base2_type::post(function, handler);
+    base2_type::dispatch(function, handler);
+  }
+
+  template <typename Function>
+  void immediate(Function& function, Handler& handler, ...)
+  {
+    typedef associated_immediate_executor_t<Handler,
+      typename base1_type::executor_type> immediate_ex_type;
+
+    immediate_ex_type immediate_ex = (get_associated_immediate_executor)(
+        handler, base1_type::get_executor());
+
+    (boost::asio::detail::initiate_dispatch_with_executor<immediate_ex_type>(
+          immediate_ex))(static_cast<Function&&>(function));
+  }
+
+  template <typename Function>
+  void immediate(Function& function, Handler&,
+      enable_if_t<
+        is_same<
+          typename associated_immediate_executor<
+            conditional_t<false, Function, Handler>,
+            typename base1_type::executor_type>::
+              asio_associated_immediate_executor_is_unspecialised,
+          void
+        >::value
+      >*)
+  {
+    (boost::asio::detail::initiate_post_with_executor<
+        typename base1_type::executor_type>(
+          base1_type::get_executor()))(
+        static_cast<Function&&>(function));
   }
 };
 
 template <typename Handler, typename IoExecutor>
 class channel_operation::handler_work<
     Handler, IoExecutor,
-    typename enable_if<
+    enable_if_t<
       is_same<
         typename associated_executor<Handler,
           IoExecutor>::asio_associated_executor_is_unspecialised,
         void
       >::value
-    >::type> : handler_work_base<IoExecutor>
+    >
+  > : handler_work_base<IoExecutor>
 {
 public:
   typedef channel_operation::handler_work_base<IoExecutor> base1_type;
 
-  handler_work(Handler&, const IoExecutor& io_ex) BOOST_ASIO_NOEXCEPT
+  handler_work(Handler&, const IoExecutor& io_ex) noexcept
     : base1_type(0, io_ex)
   {
   }
 
   template <typename Function>
-  void complete(Function& function, Handler& handler)
+  void post(Function& function, Handler& handler)
+  {
+    base1_type::post(base1_type::get_executor(), function, handler);
+  }
+
+  template <typename Function>
+  void dispatch(Function& function, Handler& handler)
+  {
+    base1_type::dispatch(function, handler);
+  }
+
+  template <typename Function>
+  void immediate(Function& function, Handler& handler, ...)
+  {
+    typedef associated_immediate_executor_t<Handler,
+      typename base1_type::executor_type> immediate_ex_type;
+
+    immediate_ex_type immediate_ex = (get_associated_immediate_executor)(
+        handler, base1_type::get_executor());
+
+    (boost::asio::detail::initiate_dispatch_with_executor<immediate_ex_type>(
+          immediate_ex))(static_cast<Function&&>(function));
+  }
+
+  template <typename Function>
+  void immediate(Function& function, Handler& handler,
+      enable_if_t<
+        is_same<
+          typename associated_immediate_executor<
+            conditional_t<false, Function, Handler>,
+            typename base1_type::executor_type>::
+              asio_associated_immediate_executor_is_unspecialised,
+          void
+        >::value
+      >*)
   {
-    base1_type::post(function, handler);
+    base1_type::post(base1_type::get_executor(), function, handler);
   }
 };
 

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

@@ -2,7 +2,7 @@
 // experimental/detail/channel_payload.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2024 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,10 +16,16 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <variant>
 #include <boost/asio/detail/type_traits.hpp>
+#include <boost/system/error_code.hpp>
 #include <boost/asio/experimental/detail/channel_message.hpp>
 
+#if defined(BOOST_ASIO_HAS_STD_VARIANT)
+# include <variant>
+#else // defined(BOOST_ASIO_HAS_STD_VARIANT)
+# include <new>
+#endif // defined(BOOST_ASIO_HAS_STD_VARIANT)
+
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -27,13 +33,52 @@ namespace asio {
 namespace experimental {
 namespace detail {
 
+template <typename... Signatures>
+class channel_payload;
+
+template <typename R>
+class channel_payload<R()>
+{
+public:
+  explicit channel_payload(channel_message<R()>)
+  {
+  }
+
+  template <typename Handler>
+  void receive(Handler& handler)
+  {
+    static_cast<Handler&&>(handler)();
+  }
+};
+
+template <typename Signature>
+class channel_payload<Signature>
+{
+public:
+  channel_payload(channel_message<Signature>&& m)
+    : message_(static_cast<channel_message<Signature>&&>(m))
+  {
+  }
+
+  template <typename Handler>
+  void receive(Handler& handler)
+  {
+    message_.receive(handler);
+  }
+
+private:
+  channel_message<Signature> message_;
+};
+
+#if defined(BOOST_ASIO_HAS_STD_VARIANT)
+
 template <typename... Signatures>
 class channel_payload
 {
 public:
   template <typename Signature>
-  channel_payload(BOOST_ASIO_MOVE_ARG(channel_message<Signature>) m)
-    : message_(BOOST_ASIO_MOVE_CAST(channel_message<Signature>)(m))
+  channel_payload(channel_message<Signature>&& m)
+    : message_(static_cast<channel_message<Signature>&&>(m))
   {
   }
 
@@ -51,40 +96,124 @@ private:
   std::variant<channel_message<Signatures>...> message_;
 };
 
-template <typename R>
-class channel_payload<R()>
+#else // defined(BOOST_ASIO_HAS_STD_VARIANT)
+
+template <typename R1, typename R2>
+class channel_payload<R1(), R2(boost::system::error_code)>
 {
 public:
-  explicit channel_payload(channel_message<R()>)
+  typedef channel_message<R1()> void_message_type;
+  typedef channel_message<R2(boost::system::error_code)> error_message_type;
+
+  channel_payload(void_message_type&&)
+    : message_(0, boost::system::error_code()),
+      empty_(true)
+  {
+  }
+
+  channel_payload(error_message_type&& m)
+    : message_(static_cast<error_message_type&&>(m)),
+      empty_(false)
   {
   }
 
   template <typename Handler>
   void receive(Handler& handler)
   {
-    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)();
+    if (empty_)
+      channel_message<R1()>(0).receive(handler);
+    else
+      message_.receive(handler);
   }
+
+private:
+  error_message_type message_;
+  bool empty_;
 };
 
-template <typename Signature>
-class channel_payload<Signature>
+template <typename Sig1, typename Sig2>
+class channel_payload<Sig1, Sig2>
 {
 public:
-  channel_payload(BOOST_ASIO_MOVE_ARG(channel_message<Signature>) m)
-    : message_(BOOST_ASIO_MOVE_CAST(channel_message<Signature>)(m))
+  typedef channel_message<Sig1> message_1_type;
+  typedef channel_message<Sig2> message_2_type;
+
+  channel_payload(message_1_type&& m)
+    : index_(1)
+  {
+    new (&storage_.message_1_) message_1_type(static_cast<message_1_type&&>(m));
+  }
+
+  channel_payload(message_2_type&& m)
+    : index_(2)
+  {
+    new (&storage_.message_2_) message_2_type(static_cast<message_2_type&&>(m));
+  }
+
+  channel_payload(channel_payload&& other)
+    : index_(other.index_)
   {
+    switch (index_)
+    {
+    case 1:
+      new (&storage_.message_1_) message_1_type(
+          static_cast<message_1_type&&>(other.storage_.message_1_));
+      break;
+    case 2:
+      new (&storage_.message_2_) message_2_type(
+          static_cast<message_2_type&&>(other.storage_.message_2_));
+      break;
+    default:
+      break;
+    }
+  }
+
+  ~channel_payload()
+  {
+    switch (index_)
+    {
+    case 1:
+      storage_.message_1_.~message_1_type();
+      break;
+    case 2:
+      storage_.message_2_.~message_2_type();
+      break;
+    default:
+      break;
+    }
   }
 
   template <typename Handler>
   void receive(Handler& handler)
   {
-    message_.receive(handler);
+    switch (index_)
+    {
+    case 1:
+      storage_.message_1_.receive(handler);
+      break;
+    case 2:
+      storage_.message_2_.receive(handler);
+      break;
+    default:
+      break;
+    }
   }
 
 private:
-  channel_message<Signature> message_;
+  union storage
+  {
+    storage() {}
+    ~storage() {}
+
+    char dummy_;
+    message_1_type message_1_;
+    message_2_type message_2_;
+  } storage_;
+  unsigned char index_;
 };
 
+#endif // defined(BOOST_ASIO_HAS_STD_VARIANT)
+
 } // namespace detail
 } // namespace experimental
 } // namespace asio

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

@@ -2,7 +2,7 @@
 // experimental/detail/channel_receive_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2024 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)
@@ -34,9 +34,19 @@ template <typename Payload>
 class channel_receive : public channel_operation
 {
 public:
-  void complete(Payload payload)
+  void immediate(Payload payload)
   {
-    func_(this, complete_op, &payload);
+    func_(this, immediate_op, &payload);
+  }
+
+  void post(Payload payload)
+  {
+    func_(this, post_op, &payload);
+  }
+
+  void dispatch(Payload payload)
+  {
+    func_(this, dispatch_op, &payload);
   }
 
 protected:
@@ -55,7 +65,7 @@ public:
   template <typename... Args>
   channel_receive_op(Handler& handler, const IoExecutor& io_ex)
     : channel_receive<Payload>(&channel_receive_op::do_action),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      handler_(static_cast<Handler&&>(handler)),
       work_(handler_, io_ex)
   {
   }
@@ -71,8 +81,8 @@ public:
 
     // Take ownership of the operation's outstanding work.
     channel_operation::handler_work<Handler, IoExecutor> w(
-        BOOST_ASIO_MOVE_CAST2(channel_operation::handler_work<
-          Handler, IoExecutor>)(o->work_));
+        static_cast<channel_operation::handler_work<Handler, IoExecutor>&&>(
+          o->work_));
 
     // Make a copy of the handler so that the memory can be deallocated before
     // the handler is posted. Even if we're not about to post the handler, a
@@ -80,15 +90,20 @@ public:
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
-    if (a == channel_operation::complete_op)
+    if (a != channel_operation::destroy_op)
     {
       Payload* payload = static_cast<Payload*>(v);
       channel_handler<Payload, Handler> handler(
-          BOOST_ASIO_MOVE_CAST(Payload)(*payload), o->handler_);
+          static_cast<Payload&&>(*payload), o->handler_);
       p.h = boost::asio::detail::addressof(handler.handler_);
       p.reset();
       BOOST_ASIO_HANDLER_INVOCATION_BEGIN(());
-      w.complete(handler, handler.handler_);
+      if (a == channel_operation::immediate_op)
+        w.immediate(handler, handler.handler_, 0);
+      else if (a == channel_operation::dispatch_op)
+        w.dispatch(handler, handler.handler_);
+      else
+        w.post(handler, handler.handler_);
       BOOST_ASIO_HANDLER_INVOCATION_END;
     }
     else