passenger 6.0.20 → 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-2023 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)
@@ -40,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>
@@ -56,9 +56,10 @@ protected:
   {
     destroy_op = 0,
     immediate_op = 1,
-    complete_op = 2,
-    cancel_op = 3,
-    close_op = 4
+    post_op = 2,
+    dispatch_op = 3,
+    cancel_op = 4,
+    close_op = 5
   };
 
   typedef void (*func_type)(channel_operation*, action, void*);
@@ -84,44 +85,96 @@ public:
   void* cancellation_key_;
 };
 
-template <typename Executor, typename>
+template <typename Executor, typename, typename>
 class channel_operation::handler_work_base
 {
 public:
-  typedef typename decay<
-      typename prefer_result<Executor,
+  typedef decay_t<
+      prefer_result_t<Executor,
         execution::outstanding_work_t::tracked_t
-      >::type
-    >::type executor_type;
+      >
+    > executor_type;
 
   handler_work_base(int, const Executor& ex)
     : executor_(boost::asio::prefer(ex, execution::outstanding_work.tracked))
   {
   }
 
-  const executor_type& get_executor() const BOOST_ASIO_NOEXCEPT
+  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)
+  {
+    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)
   {
-    typename associated_allocator<Handler>::type allocator =
+    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:
@@ -132,9 +185,10 @@ private:
 
 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;
@@ -144,19 +198,29 @@ public:
   {
   }
 
-  executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+  executor_type get_executor() const noexcept
   {
     return work_.get_executor();
   }
 
-  template <typename Function, typename Handler>
-  void post(Function& function, Handler& handler)
+  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:
@@ -169,110 +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(function, handler);
+    base2_type::post(base1_type::get_executor(), function, handler);
+  }
+
+  template <typename Function>
+  void dispatch(Function& function, Handler& handler)
+  {
+    base2_type::dispatch(function, handler);
   }
 
   template <typename Function>
   void immediate(Function& function, Handler& handler, ...)
   {
-    typedef typename associated_immediate_executor<Handler,
-      typename base1_type::executor_type>::type immediate_ex_type;
+    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))(BOOST_ASIO_MOVE_CAST(Function)(function));
+          immediate_ex))(static_cast<Function&&>(function));
   }
 
   template <typename Function>
   void immediate(Function& function, Handler&,
-      typename enable_if<
+      enable_if_t<
         is_same<
           typename associated_immediate_executor<
-            typename conditional<false, Function, Handler>::type,
+            conditional_t<false, Function, Handler>,
             typename base1_type::executor_type>::
               asio_associated_immediate_executor_is_unspecialised,
           void
         >::value
-      >::type*)
+      >*)
   {
     (boost::asio::detail::initiate_post_with_executor<
         typename base1_type::executor_type>(
           base1_type::get_executor()))(
-        BOOST_ASIO_MOVE_CAST(Function)(function));
+        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::post(function, handler);
+    base1_type::dispatch(function, handler);
   }
 
   template <typename Function>
   void immediate(Function& function, Handler& handler, ...)
   {
-    typedef typename associated_immediate_executor<Handler,
-      typename base1_type::executor_type>::type immediate_ex_type;
+    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))(BOOST_ASIO_MOVE_CAST(Function)(function));
+          immediate_ex))(static_cast<Function&&>(function));
   }
 
   template <typename Function>
   void immediate(Function& function, Handler& handler,
-      typename enable_if<
+      enable_if_t<
         is_same<
           typename associated_immediate_executor<
-            typename conditional<false, Function, Handler>::type,
+            conditional_t<false, Function, Handler>,
             typename base1_type::executor_type>::
               asio_associated_immediate_executor_is_unspecialised,
           void
         >::value
-      >::type*)
+      >*)
   {
-    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-2023 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)
@@ -22,6 +22,8 @@
 
 #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>
@@ -45,7 +47,7 @@ public:
   template <typename Handler>
   void receive(Handler& handler)
   {
-    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)();
+    static_cast<Handler&&>(handler)();
   }
 };
 
@@ -53,8 +55,8 @@ template <typename Signature>
 class channel_payload<Signature>
 {
 public:
-  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))
   {
   }
 
@@ -75,8 +77,8 @@ 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))
   {
   }
 
@@ -103,14 +105,14 @@ public:
   typedef channel_message<R1()> void_message_type;
   typedef channel_message<R2(boost::system::error_code)> error_message_type;
 
-  channel_payload(BOOST_ASIO_MOVE_ARG(void_message_type))
+  channel_payload(void_message_type&&)
     : message_(0, boost::system::error_code()),
       empty_(true)
   {
   }
 
-  channel_payload(BOOST_ASIO_MOVE_ARG(error_message_type) m)
-    : message_(BOOST_ASIO_MOVE_CAST(error_message_type)(m)),
+  channel_payload(error_message_type&& m)
+    : message_(static_cast<error_message_type&&>(m)),
       empty_(false)
   {
   }
@@ -129,6 +131,87 @@ private:
   bool empty_;
 };
 
+template <typename Sig1, typename Sig2>
+class channel_payload<Sig1, Sig2>
+{
+public:
+  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)
+  {
+    switch (index_)
+    {
+    case 1:
+      storage_.message_1_.receive(handler);
+      break;
+    case 2:
+      storage_.message_2_.receive(handler);
+      break;
+    default:
+      break;
+    }
+  }
+
+private:
+  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

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-2023 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)
@@ -39,9 +39,14 @@ public:
     func_(this, immediate_op, &payload);
   }
 
-  void complete(Payload payload)
+  void post(Payload payload)
   {
-    func_(this, complete_op, &payload);
+    func_(this, post_op, &payload);
+  }
+
+  void dispatch(Payload payload)
+  {
+    func_(this, dispatch_op, &payload);
   }
 
 protected:
@@ -60,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)
   {
   }
@@ -76,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
@@ -89,14 +94,16 @@ public:
     {
       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(());
       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.complete(handler, handler.handler_);
+        w.post(handler, handler.handler_);
       BOOST_ASIO_HANDLER_INVOCATION_END;
     }
     else