passenger 6.0.20 → 6.0.21

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/src.hpp

@@ -2,7 +2,7 @@
 // impl/src.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)
@@ -26,7 +26,6 @@
 #include <boost/asio/impl/error.ipp>
 #include <boost/asio/impl/execution_context.ipp>
 #include <boost/asio/impl/executor.ipp>
-#include <boost/asio/impl/handler_alloc_hook.ipp>
 #include <boost/asio/impl/io_context.ipp>
 #include <boost/asio/impl/multiple_exceptions.ipp>
 #include <boost/asio/impl/serial_port_base.ipp>
@@ -80,7 +79,6 @@
 #include <boost/asio/detail/impl/winrt_timer_scheduler.ipp>
 #include <boost/asio/detail/impl/winsock_init.ipp>
 #include <boost/asio/execution/impl/bad_executor.ipp>
-#include <boost/asio/execution/impl/receiver_invocation_error.ipp>
 #include <boost/asio/experimental/impl/channel_error.ipp>
 #include <boost/asio/generic/detail/impl/endpoint.ipp>
 #include <boost/asio/ip/impl/address.ipp>

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/system_context.hpp

@@ -2,7 +2,7 @@
 // impl/system_context.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)
@@ -23,7 +23,7 @@ namespace boost {
 namespace asio {
 
 inline system_context::executor_type
-system_context::get_executor() BOOST_ASIO_NOEXCEPT
+system_context::get_executor() noexcept
 {
   return system_executor();
 }

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/system_context.ipp

@@ -2,7 +2,7 @@
 // impl/system_context.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// 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)
@@ -68,7 +68,7 @@ void system_context::stop()
   scheduler_.stop();
 }
 
-bool system_context::stopped() const BOOST_ASIO_NOEXCEPT
+bool system_context::stopped() const noexcept
 {
   return scheduler_.stopped();
 }

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/system_executor.hpp

@@ -2,7 +2,7 @@
 // impl/system_executor.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)
@@ -28,7 +28,7 @@ namespace asio {
 template <typename Blocking, typename Relationship, typename Allocator>
 inline system_context&
 basic_system_executor<Blocking, Relationship, Allocator>::query(
-    execution::context_t) BOOST_ASIO_NOEXCEPT
+    execution::context_t) noexcept
 {
   return detail::global<system_context>();
 }
@@ -36,7 +36,7 @@ basic_system_executor<Blocking, Relationship, Allocator>::query(
 template <typename Blocking, typename Relationship, typename Allocator>
 inline std::size_t
 basic_system_executor<Blocking, Relationship, Allocator>::query(
-    execution::occupancy_t) const BOOST_ASIO_NOEXCEPT
+    execution::occupancy_t) const noexcept
 {
   return detail::global<system_context>().num_threads_;
 }
@@ -45,7 +45,7 @@ template <typename Blocking, typename Relationship, typename Allocator>
 template <typename Function>
 inline void
 basic_system_executor<Blocking, Relationship, Allocator>::do_execute(
-    BOOST_ASIO_MOVE_ARG(Function) f, execution::blocking_t::possibly_t) const
+    Function&& f, execution::blocking_t::possibly_t) const
 {
   // Obtain a non-const instance of the function.
   detail::non_const_lvalue<Function> f2(f);
@@ -55,7 +55,7 @@ basic_system_executor<Blocking, Relationship, Allocator>::do_execute(
   {
 #endif// !defined(BOOST_ASIO_NO_EXCEPTIONS)
     detail::fenced_block b(detail::fenced_block::full);
-    boost_asio_handler_invoke_helpers::invoke(f2.value, f2.value);
+    static_cast<decay_t<Function>&&>(f2.value)();
 #if !defined(BOOST_ASIO_NO_EXCEPTIONS)
   }
   catch (...)
@@ -69,7 +69,7 @@ template <typename Blocking, typename Relationship, typename Allocator>
 template <typename Function>
 inline void
 basic_system_executor<Blocking, Relationship, Allocator>::do_execute(
-    BOOST_ASIO_MOVE_ARG(Function) f, execution::blocking_t::always_t) const
+    Function&& f, execution::blocking_t::always_t) const
 {
   // Obtain a non-const instance of the function.
   detail::non_const_lvalue<Function> f2(f);
@@ -79,7 +79,7 @@ basic_system_executor<Blocking, Relationship, Allocator>::do_execute(
   {
 #endif// !defined(BOOST_ASIO_NO_EXCEPTIONS)
     detail::fenced_block b(detail::fenced_block::full);
-    boost_asio_handler_invoke_helpers::invoke(f2.value, f2.value);
+    static_cast<decay_t<Function>&&>(f2.value)();
 #if !defined(BOOST_ASIO_NO_EXCEPTIONS)
   }
   catch (...)
@@ -92,16 +92,15 @@ basic_system_executor<Blocking, Relationship, Allocator>::do_execute(
 template <typename Blocking, typename Relationship, typename Allocator>
 template <typename Function>
 void basic_system_executor<Blocking, Relationship, Allocator>::do_execute(
-    BOOST_ASIO_MOVE_ARG(Function) f, execution::blocking_t::never_t) const
+    Function&& f, execution::blocking_t::never_t) const
 {
   system_context& ctx = detail::global<system_context>();
 
   // Allocate and construct an operation to wrap the function.
-  typedef typename decay<Function>::type function_type;
-  typedef detail::executor_op<function_type, Allocator> op;
+  typedef detail::executor_op<decay_t<Function>, Allocator> op;
   typename op::ptr p = { detail::addressof(allocator_),
       op::ptr::allocate(allocator_), 0 };
-  p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f), allocator_);
+  p.p = new (p.v) op(static_cast<Function&&>(f), allocator_);
 
   if (is_same<Relationship, execution::relationship_t::continuation_t>::value)
   {
@@ -122,7 +121,7 @@ void basic_system_executor<Blocking, Relationship, Allocator>::do_execute(
 #if !defined(BOOST_ASIO_NO_TS_EXECUTORS)
 template <typename Blocking, typename Relationship, typename Allocator>
 inline system_context& basic_system_executor<
-    Blocking, Relationship, Allocator>::context() const BOOST_ASIO_NOEXCEPT
+    Blocking, Relationship, Allocator>::context() const noexcept
 {
   return detail::global<system_context>();
 }
@@ -130,25 +129,22 @@ inline system_context& basic_system_executor<
 template <typename Blocking, typename Relationship, typename Allocator>
 template <typename Function, typename OtherAllocator>
 void basic_system_executor<Blocking, Relationship, Allocator>::dispatch(
-    BOOST_ASIO_MOVE_ARG(Function) f, const OtherAllocator&) const
+    Function&& f, const OtherAllocator&) const
 {
-  typename decay<Function>::type tmp(BOOST_ASIO_MOVE_CAST(Function)(f));
-  boost_asio_handler_invoke_helpers::invoke(tmp, tmp);
+  decay_t<Function>(static_cast<Function&&>(f))();
 }
 
 template <typename Blocking, typename Relationship, typename Allocator>
 template <typename Function, typename OtherAllocator>
 void basic_system_executor<Blocking, Relationship, Allocator>::post(
-    BOOST_ASIO_MOVE_ARG(Function) f, const OtherAllocator& a) const
+    Function&& f, const OtherAllocator& a) const
 {
-  typedef typename decay<Function>::type function_type;
-
   system_context& ctx = detail::global<system_context>();
 
   // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, OtherAllocator> op;
+  typedef detail::executor_op<decay_t<Function>, OtherAllocator> op;
   typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f), a);
+  p.p = new (p.v) op(static_cast<Function&&>(f), a);
 
   BOOST_ASIO_HANDLER_CREATION((ctx, *p.p,
         "system_executor", &this->context(), 0, "post"));
@@ -160,16 +156,14 @@ void basic_system_executor<Blocking, Relationship, Allocator>::post(
 template <typename Blocking, typename Relationship, typename Allocator>
 template <typename Function, typename OtherAllocator>
 void basic_system_executor<Blocking, Relationship, Allocator>::defer(
-    BOOST_ASIO_MOVE_ARG(Function) f, const OtherAllocator& a) const
+    Function&& f, const OtherAllocator& a) const
 {
-  typedef typename decay<Function>::type function_type;
-
   system_context& ctx = detail::global<system_context>();
 
   // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, OtherAllocator> op;
+  typedef detail::executor_op<decay_t<Function>, OtherAllocator> op;
   typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f), a);
+  p.p = new (p.v) op(static_cast<Function&&>(f), a);
 
   BOOST_ASIO_HANDLER_CREATION((ctx, *p.p,
         "system_executor", &this->context(), 0, "defer"));

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/thread_pool.hpp

@@ -2,7 +2,7 @@
 // impl/thread_pool.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)
@@ -16,7 +16,6 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/blocking_executor_op.hpp>
-#include <boost/asio/detail/bulk_executor_op.hpp>
 #include <boost/asio/detail/executor_op.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/non_const_lvalue.hpp>
@@ -29,27 +28,21 @@ namespace boost {
 namespace asio {
 
 inline thread_pool::executor_type
-thread_pool::get_executor() BOOST_ASIO_NOEXCEPT
+thread_pool::get_executor() noexcept
 {
   return executor_type(*this);
 }
 
 inline thread_pool::executor_type
-thread_pool::executor() BOOST_ASIO_NOEXCEPT
+thread_pool::executor() noexcept
 {
   return executor_type(*this);
 }
 
-inline thread_pool::scheduler_type
-thread_pool::scheduler() BOOST_ASIO_NOEXCEPT
-{
-  return scheduler_type(*this);
-}
-
 template <typename Allocator, unsigned int Bits>
 thread_pool::basic_executor_type<Allocator, Bits>&
 thread_pool::basic_executor_type<Allocator, Bits>::operator=(
-    const basic_executor_type& other) BOOST_ASIO_NOEXCEPT
+    const basic_executor_type& other) noexcept
 {
   if (this != &other)
   {
@@ -68,11 +61,10 @@ thread_pool::basic_executor_type<Allocator, Bits>::operator=(
   return *this;
 }
 
-#if defined(BOOST_ASIO_HAS_MOVE)
 template <typename Allocator, unsigned int Bits>
 thread_pool::basic_executor_type<Allocator, Bits>&
 thread_pool::basic_executor_type<Allocator, Bits>::operator=(
-    basic_executor_type&& other) BOOST_ASIO_NOEXCEPT
+    basic_executor_type&& other) noexcept
 {
   if (this != &other)
   {
@@ -89,11 +81,10 @@ thread_pool::basic_executor_type<Allocator, Bits>::operator=(
   }
   return *this;
 }
-#endif // defined(BOOST_ASIO_HAS_MOVE)
 
 template <typename Allocator, unsigned int Bits>
 inline bool thread_pool::basic_executor_type<Allocator,
-    Bits>::running_in_this_thread() const BOOST_ASIO_NOEXCEPT
+    Bits>::running_in_this_thread() const noexcept
 {
   return pool_->scheduler_.can_dispatch();
 }
@@ -101,43 +92,39 @@ inline bool thread_pool::basic_executor_type<Allocator,
 template <typename Allocator, unsigned int Bits>
 template <typename Function>
 void thread_pool::basic_executor_type<Allocator,
-    Bits>::do_execute(BOOST_ASIO_MOVE_ARG(Function) f, false_type) const
+    Bits>::do_execute(Function&& f, false_type) const
 {
-  typedef typename decay<Function>::type function_type;
+  typedef decay_t<Function> function_type;
 
   // Invoke immediately if the blocking.possibly property is enabled and we are
   // already inside the thread pool.
   if ((bits_ & blocking_never) == 0 && pool_->scheduler_.can_dispatch())
   {
     // Make a local, non-const copy of the function.
-    function_type tmp(BOOST_ASIO_MOVE_CAST(Function)(f));
+    function_type tmp(static_cast<Function&&>(f));
 
-#if defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) \
-  && !defined(BOOST_ASIO_NO_EXCEPTIONS)
+#if !defined(BOOST_ASIO_NO_EXCEPTIONS)
     try
     {
-#endif // defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR)
-       //   && !defined(BOOST_ASIO_NO_EXCEPTIONS)
+#endif // !defined(BOOST_ASIO_NO_EXCEPTIONS)
       detail::fenced_block b(detail::fenced_block::full);
-      boost_asio_handler_invoke_helpers::invoke(tmp, tmp);
+      static_cast<function_type&&>(tmp)();
       return;
-#if defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) \
-  && !defined(BOOST_ASIO_NO_EXCEPTIONS)
+#if !defined(BOOST_ASIO_NO_EXCEPTIONS)
     }
     catch (...)
     {
       pool_->scheduler_.capture_current_exception();
       return;
     }
-#endif // defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR)
-       //   && !defined(BOOST_ASIO_NO_EXCEPTIONS)
+#endif // !defined(BOOST_ASIO_NO_EXCEPTIONS)
   }
 
   // Allocate and construct an operation to wrap the function.
   typedef detail::executor_op<function_type, Allocator> op;
   typename op::ptr p = { detail::addressof(allocator_),
       op::ptr::allocate(allocator_), 0 };
-  p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f), allocator_);
+  p.p = new (p.v) op(static_cast<Function&&>(f), allocator_);
 
   if ((bits_ & relationship_continuation) != 0)
   {
@@ -158,7 +145,7 @@ void thread_pool::basic_executor_type<Allocator,
 template <typename Allocator, unsigned int Bits>
 template <typename Function>
 void thread_pool::basic_executor_type<Allocator,
-    Bits>::do_execute(BOOST_ASIO_MOVE_ARG(Function) f, true_type) const
+    Bits>::do_execute(Function&& f, true_type) const
 {
   // Obtain a non-const instance of the function.
   detail::non_const_lvalue<Function> f2(f);
@@ -171,7 +158,7 @@ void thread_pool::basic_executor_type<Allocator,
     {
 #endif // !defined(BOOST_ASIO_NO_EXCEPTIONS)
       detail::fenced_block b(detail::fenced_block::full);
-      boost_asio_handler_invoke_helpers::invoke(f2.value, f2.value);
+      static_cast<decay_t<Function>&&>(f2.value)();
       return;
 #if !defined(BOOST_ASIO_NO_EXCEPTIONS)
     }
@@ -183,7 +170,7 @@ void thread_pool::basic_executor_type<Allocator,
   }
 
   // Construct an operation to wrap the function.
-  typedef typename decay<Function>::type function_type;
+  typedef decay_t<Function> function_type;
   detail::blocking_executor_op<function_type> op(f2.value);
 
   BOOST_ASIO_HANDLER_CREATION((*pool_, op,
@@ -193,88 +180,24 @@ void thread_pool::basic_executor_type<Allocator,
   op.wait();
 }
 
-template <typename Allocator, unsigned int Bits>
-template <typename Function>
-void thread_pool::basic_executor_type<Allocator, Bits>::do_bulk_execute(
-    BOOST_ASIO_MOVE_ARG(Function) f, std::size_t n, false_type) const
-{
-  typedef typename decay<Function>::type function_type;
-  typedef detail::bulk_executor_op<function_type, Allocator> op;
-
-  // Allocate and construct operations to wrap the function.
-  detail::op_queue<detail::scheduler_operation> ops;
-  for (std::size_t i = 0; i < n; ++i)
-  {
-    typename op::ptr p = { detail::addressof(allocator_),
-        op::ptr::allocate(allocator_), 0 };
-    p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f), allocator_, i);
-    ops.push(p.p);
-
-    if ((bits_ & relationship_continuation) != 0)
-    {
-      BOOST_ASIO_HANDLER_CREATION((*pool_, *p.p,
-            "thread_pool", pool_, 0, "bulk_execute(blk=never,rel=cont)"));
-    }
-    else
-    {
-      BOOST_ASIO_HANDLER_CREATION((*pool_, *p.p,
-            "thread_pool", pool_, 0, "bulk)execute(blk=never,rel=fork)"));
-    }
-
-    p.v = p.p = 0;
-  }
-
-  pool_->scheduler_.post_immediate_completions(n,
-      ops, (bits_ & relationship_continuation) != 0);
-}
-
-template <typename Function>
-struct thread_pool_always_blocking_function_adapter
-{
-  typename decay<Function>::type* f;
-  std::size_t n;
-
-  void operator()()
-  {
-    for (std::size_t i = 0; i < n; ++i)
-    {
-      (*f)(i);
-    }
-  }
-};
-
-template <typename Allocator, unsigned int Bits>
-template <typename Function>
-void thread_pool::basic_executor_type<Allocator, Bits>::do_bulk_execute(
-    BOOST_ASIO_MOVE_ARG(Function) f, std::size_t n, true_type) const
-{
-  // Obtain a non-const instance of the function.
-  detail::non_const_lvalue<Function> f2(f);
-
-  thread_pool_always_blocking_function_adapter<Function>
-    adapter = { detail::addressof(f2.value), n };
-
-  this->do_execute(adapter, true_type());
-}
-
 #if !defined(BOOST_ASIO_NO_TS_EXECUTORS)
 template <typename Allocator, unsigned int Bits>
 inline thread_pool& thread_pool::basic_executor_type<
-    Allocator, Bits>::context() const BOOST_ASIO_NOEXCEPT
+    Allocator, Bits>::context() const noexcept
 {
   return *pool_;
 }
 
 template <typename Allocator, unsigned int Bits>
 inline void thread_pool::basic_executor_type<Allocator,
-    Bits>::on_work_started() const BOOST_ASIO_NOEXCEPT
+    Bits>::on_work_started() const noexcept
 {
   pool_->scheduler_.work_started();
 }
 
 template <typename Allocator, unsigned int Bits>
 inline void thread_pool::basic_executor_type<Allocator,
-    Bits>::on_work_finished() const BOOST_ASIO_NOEXCEPT
+    Bits>::on_work_finished() const noexcept
 {
   pool_->scheduler_.work_finished();
 }
@@ -282,25 +205,25 @@ inline void thread_pool::basic_executor_type<Allocator,
 template <typename Allocator, unsigned int Bits>
 template <typename Function, typename OtherAllocator>
 void thread_pool::basic_executor_type<Allocator, Bits>::dispatch(
-    BOOST_ASIO_MOVE_ARG(Function) f, const OtherAllocator& a) const
+    Function&& f, const OtherAllocator& a) const
 {
-  typedef typename decay<Function>::type function_type;
+  typedef decay_t<Function> function_type;
 
   // Invoke immediately if we are already inside the thread pool.
   if (pool_->scheduler_.can_dispatch())
   {
     // Make a local, non-const copy of the function.
-    function_type tmp(BOOST_ASIO_MOVE_CAST(Function)(f));
+    function_type tmp(static_cast<Function&&>(f));
 
     detail::fenced_block b(detail::fenced_block::full);
-    boost_asio_handler_invoke_helpers::invoke(tmp, tmp);
+    static_cast<function_type&&>(tmp)();
     return;
   }
 
   // Allocate and construct an operation to wrap the function.
   typedef detail::executor_op<function_type, OtherAllocator> op;
   typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f), a);
+  p.p = new (p.v) op(static_cast<Function&&>(f), a);
 
   BOOST_ASIO_HANDLER_CREATION((*pool_, *p.p,
         "thread_pool", pool_, 0, "dispatch"));
@@ -312,14 +235,14 @@ void thread_pool::basic_executor_type<Allocator, Bits>::dispatch(
 template <typename Allocator, unsigned int Bits>
 template <typename Function, typename OtherAllocator>
 void thread_pool::basic_executor_type<Allocator, Bits>::post(
-    BOOST_ASIO_MOVE_ARG(Function) f, const OtherAllocator& a) const
+    Function&& f, const OtherAllocator& a) const
 {
-  typedef typename decay<Function>::type function_type;
+  typedef decay_t<Function> function_type;
 
   // Allocate and construct an operation to wrap the function.
   typedef detail::executor_op<function_type, OtherAllocator> op;
   typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f), a);
+  p.p = new (p.v) op(static_cast<Function&&>(f), a);
 
   BOOST_ASIO_HANDLER_CREATION((*pool_, *p.p,
         "thread_pool", pool_, 0, "post"));
@@ -331,14 +254,14 @@ void thread_pool::basic_executor_type<Allocator, Bits>::post(
 template <typename Allocator, unsigned int Bits>
 template <typename Function, typename OtherAllocator>
 void thread_pool::basic_executor_type<Allocator, Bits>::defer(
-    BOOST_ASIO_MOVE_ARG(Function) f, const OtherAllocator& a) const
+    Function&& f, const OtherAllocator& a) const
 {
-  typedef typename decay<Function>::type function_type;
+  typedef decay_t<Function> function_type;
 
   // Allocate and construct an operation to wrap the function.
   typedef detail::executor_op<function_type, OtherAllocator> op;
   typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f), a);
+  p.p = new (p.v) op(static_cast<Function&&>(f), a);
 
   BOOST_ASIO_HANDLER_CREATION((*pool_, *p.p,
         "thread_pool", pool_, 0, "defer"));

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/thread_pool.ipp

@@ -2,7 +2,7 @@
 // impl/thread_pool.ipp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// 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)

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/use_awaitable.hpp

@@ -2,7 +2,7 @@
 // impl/use_awaitable.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)
@@ -259,7 +259,7 @@ class async_result<use_awaitable_t<Executor>, R(Args...)>
 {
 public:
   typedef typename detail::awaitable_handler<
-      Executor, typename decay<Args>::type...> handler_type;
+      Executor, decay_t<Args>...> handler_type;
   typedef typename handler_type::awaitable_type return_type;
 
   template <typename Initiation, typename... InitArgs>