passenger 6.0.20 → 6.0.21

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

@@ -2,7 +2,7 @@
 // spawn.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)
@@ -77,12 +77,12 @@ public:
     suspend_with(&spawned_thread_base::call<F>, &f);
   }
 
-  cancellation_slot get_cancellation_slot() const BOOST_ASIO_NOEXCEPT
+  cancellation_slot get_cancellation_slot() const noexcept
   {
     return cancellation_state_.slot();
   }
 
-  cancellation_state get_cancellation_state() const BOOST_ASIO_NOEXCEPT
+  cancellation_state get_cancellation_state() const noexcept
   {
     return cancellation_state_;
   }
@@ -106,22 +106,22 @@ public:
         parent_cancellation_slot_, in_filter, out_filter);
   }
 
-  cancellation_type_t cancelled() const BOOST_ASIO_NOEXCEPT
+  cancellation_type_t cancelled() const noexcept
   {
     return cancellation_state_.cancelled();
   }
 
-  bool has_context_switched() const BOOST_ASIO_NOEXCEPT
+  bool has_context_switched() const noexcept
   {
     return has_context_switched_;
   }
 
-  bool throw_if_cancelled() const BOOST_ASIO_NOEXCEPT
+  bool throw_if_cancelled() const noexcept
   {
     return throw_if_cancelled_;
   }
 
-  void throw_if_cancelled(bool value) BOOST_ASIO_NOEXCEPT
+  void throw_if_cancelled(bool value) noexcept
   {
     throw_if_cancelled_ = value;
   }
@@ -136,8 +136,8 @@ protected:
 
 private:
   // Disallow copying and assignment.
-  spawned_thread_base(const spawned_thread_base&) BOOST_ASIO_DELETED;
-  spawned_thread_base& operator=(const spawned_thread_base&) BOOST_ASIO_DELETED;
+  spawned_thread_base(const spawned_thread_base&) = delete;
+  spawned_thread_base& operator=(const spawned_thread_base&) = delete;
 
   template <typename F>
   static void call(void* f)
@@ -199,9 +199,9 @@ public:
    */
   template <typename OtherExecutor>
   basic_yield_context(const basic_yield_context<OtherExecutor>& other,
-      typename constraint<
+      constraint_t<
         is_convertible<OtherExecutor, Executor>::value
-      >::type = 0)
+      > = 0)
     : spawned_thread_(other.spawned_thread_),
       executor_(other.executor_),
       ec_(other.ec_)
@@ -209,19 +209,19 @@ public:
   }
 
   /// Get the executor associated with the yield context.
-  executor_type get_executor() const BOOST_ASIO_NOEXCEPT
+  executor_type get_executor() const noexcept
   {
     return executor_;
   }
 
   /// Get the cancellation slot associated with the coroutine.
-  cancellation_slot_type get_cancellation_slot() const BOOST_ASIO_NOEXCEPT
+  cancellation_slot_type get_cancellation_slot() const noexcept
   {
     return spawned_thread_->get_cancellation_slot();
   }
 
   /// Get the cancellation state associated with the coroutine.
-  cancellation_state get_cancellation_state() const BOOST_ASIO_NOEXCEPT
+  cancellation_state get_cancellation_state() const noexcept
   {
     return spawned_thread_->get_cancellation_state();
   }
@@ -247,10 +247,10 @@ public:
    * cancellation state object.
    */
   template <typename Filter>
-  void reset_cancellation_state(BOOST_ASIO_MOVE_ARG(Filter) filter) const
+  void reset_cancellation_state(Filter&& filter) const
   {
     spawned_thread_->reset_cancellation_state(
-        BOOST_ASIO_MOVE_CAST(Filter)(filter));
+        static_cast<Filter&&>(filter));
   }
 
   /// Reset the cancellation state associated with the coroutine.
@@ -263,30 +263,30 @@ public:
    * cancellation state object.
    */
   template <typename InFilter, typename OutFilter>
-  void reset_cancellation_state(BOOST_ASIO_MOVE_ARG(InFilter) in_filter,
-      BOOST_ASIO_MOVE_ARG(OutFilter) out_filter) const
+  void reset_cancellation_state(InFilter&& in_filter,
+      OutFilter&& out_filter) const
   {
     spawned_thread_->reset_cancellation_state(
-        BOOST_ASIO_MOVE_CAST(InFilter)(in_filter),
-        BOOST_ASIO_MOVE_CAST(OutFilter)(out_filter));
+        static_cast<InFilter&&>(in_filter),
+        static_cast<OutFilter&&>(out_filter));
   }
 
   /// Determine whether the current coroutine has been cancelled.
-  cancellation_type_t cancelled() const BOOST_ASIO_NOEXCEPT
+  cancellation_type_t cancelled() const noexcept
   {
     return spawned_thread_->cancelled();
   }
 
   /// Determine whether the coroutine throws if trying to suspend when it has
   /// been cancelled.
-  bool throw_if_cancelled() const BOOST_ASIO_NOEXCEPT
+  bool throw_if_cancelled() const noexcept
   {
     return spawned_thread_->throw_if_cancelled();
   }
 
   /// Set whether the coroutine throws if trying to suspend when it has been
   /// cancelled.
-  void throw_if_cancelled(bool value) const BOOST_ASIO_NOEXCEPT
+  void throw_if_cancelled(bool value) const noexcept
   {
     spawned_thread_->throw_if_cancelled(value);
   }
@@ -403,31 +403,27 @@ typedef basic_yield_context<any_io_executor> yield_context;
  */
 template <typename Executor, typename F,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
-      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
-        CompletionToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken,
-    typename detail::spawn_signature<
-      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
-spawn(const Executor& ex, BOOST_ASIO_MOVE_ARG(F) function,
-    BOOST_ASIO_MOVE_ARG(CompletionToken) token
-      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
+      result_of_t<F(basic_yield_context<Executor>)>>::type)
+        CompletionToken = default_completion_token_t<Executor>>
+auto spawn(const Executor& ex, F&& function,
+    CompletionToken&& token = default_completion_token_t<Executor>(),
 #if defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
-    typename constraint<
+    constraint_t<
       !is_same<
-        typename decay<CompletionToken>::type,
+        decay_t<CompletionToken>,
         boost::coroutines::attributes
       >::value
-    >::type = 0,
+    > = 0,
 #endif // defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
-    typename constraint<
+    constraint_t<
       is_executor<Executor>::value || execution::is_executor<Executor>::value
-    >::type = 0)
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    > = 0)
+  -> decltype(
     async_initiate<CompletionToken,
       typename detail::spawn_signature<
-        typename result_of<F(basic_yield_context<Executor>)>::type>::type>(
-          declval<detail::initiate_spawn<Executor> >(),
-          token, BOOST_ASIO_MOVE_CAST(F)(function))));
+        result_of_t<F(basic_yield_context<Executor>)>>::type>(
+          declval<detail::initiate_spawn<Executor>>(),
+          token, static_cast<F&&>(function)));
 
 /// Start a new stackful coroutine that executes on a given execution context.
 /**
@@ -460,37 +456,32 @@ spawn(const Executor& ex, BOOST_ASIO_MOVE_ARG(F) function,
  */
 template <typename ExecutionContext, typename F,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
-      typename result_of<F(basic_yield_context<
-        typename ExecutionContext::executor_type>)>::type>::type)
-          CompletionToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
-            typename ExecutionContext::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken,
-    typename detail::spawn_signature<
-      typename result_of<F(basic_yield_context<
-        typename ExecutionContext::executor_type>)>::type>::type)
-spawn(ExecutionContext& ctx, BOOST_ASIO_MOVE_ARG(F) function,
-    BOOST_ASIO_MOVE_ARG(CompletionToken) token
-      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
-        typename ExecutionContext::executor_type),
+      result_of_t<F(basic_yield_context<
+        typename ExecutionContext::executor_type>)>>::type)
+          CompletionToken = default_completion_token_t<
+            typename ExecutionContext::executor_type>>
+auto spawn(ExecutionContext& ctx, F&& function,
+    CompletionToken&& token
+      = default_completion_token_t<typename ExecutionContext::executor_type>(),
 #if defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
-    typename constraint<
+    constraint_t<
       !is_same<
-        typename decay<CompletionToken>::type,
+        decay_t<CompletionToken>,
         boost::coroutines::attributes
       >::value
-    >::type = 0,
+    > = 0,
 #endif // defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
-    typename constraint<
+    constraint_t<
       is_convertible<ExecutionContext&, execution_context&>::value
-    >::type = 0)
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    > = 0)
+  -> decltype(
     async_initiate<CompletionToken,
       typename detail::spawn_signature<
-        typename result_of<F(basic_yield_context<
-          typename ExecutionContext::executor_type>)>::type>::type>(
+        result_of_t<F(basic_yield_context<
+          typename ExecutionContext::executor_type>)>>::type>(
             declval<detail::initiate_spawn<
-              typename ExecutionContext::executor_type> >(),
-            token, BOOST_ASIO_MOVE_CAST(F)(function))));
+              typename ExecutionContext::executor_type>>(),
+            token, static_cast<F&&>(function)));
 
 /// Start a new stackful coroutine, inheriting the executor of another.
 /**
@@ -525,32 +516,27 @@ spawn(ExecutionContext& ctx, BOOST_ASIO_MOVE_ARG(F) function,
  */
 template <typename Executor, typename F,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
-      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
-        CompletionToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken,
-    typename detail::spawn_signature<
-      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
-spawn(const basic_yield_context<Executor>& ctx,
-    BOOST_ASIO_MOVE_ARG(F) function,
-    BOOST_ASIO_MOVE_ARG(CompletionToken) token
-      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
+      result_of_t<F(basic_yield_context<Executor>)>>::type)
+        CompletionToken = default_completion_token_t<Executor>>
+auto spawn(const basic_yield_context<Executor>& ctx, F&& function,
+    CompletionToken&& token = default_completion_token_t<Executor>(),
 #if defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
-    typename constraint<
+    constraint_t<
       !is_same<
-        typename decay<CompletionToken>::type,
+        decay_t<CompletionToken>,
         boost::coroutines::attributes
       >::value
-    >::type = 0,
+    > = 0,
 #endif // defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
-    typename constraint<
+    constraint_t<
       is_executor<Executor>::value || execution::is_executor<Executor>::value
-    >::type = 0)
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    > = 0)
+  -> decltype(
     async_initiate<CompletionToken,
       typename detail::spawn_signature<
-        typename result_of<F(basic_yield_context<Executor>)>::type>::type>(
-          declval<detail::initiate_spawn<Executor> >(),
-          token, BOOST_ASIO_MOVE_CAST(F)(function))));
+        result_of_t<F(basic_yield_context<Executor>)>>::type>(
+          declval<detail::initiate_spawn<Executor>>(),
+          token, static_cast<F&&>(function)));
 
 #if defined(BOOST_ASIO_HAS_BOOST_CONTEXT_FIBER) \
   || defined(GENERATING_DOCUMENTATION)
@@ -590,27 +576,22 @@ spawn(const basic_yield_context<Executor>& ctx,
  */
 template <typename Executor, typename StackAllocator, typename F,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
-      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
-        CompletionToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken,
-    typename detail::spawn_signature<
-      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
-spawn(const Executor& ex, allocator_arg_t,
-    BOOST_ASIO_MOVE_ARG(StackAllocator) stack_allocator,
-    BOOST_ASIO_MOVE_ARG(F) function,
-    BOOST_ASIO_MOVE_ARG(CompletionToken) token
-      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
-    typename constraint<
+      result_of_t<F(basic_yield_context<Executor>)>>::type)
+        CompletionToken = default_completion_token_t<Executor>>
+auto spawn(const Executor& ex, allocator_arg_t,
+    StackAllocator&& stack_allocator, F&& function,
+    CompletionToken&& token = default_completion_token_t<Executor>(),
+    constraint_t<
       is_executor<Executor>::value || execution::is_executor<Executor>::value
-    >::type = 0)
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    > = 0)
+  -> decltype(
     async_initiate<CompletionToken,
       typename detail::spawn_signature<
-        typename result_of<F(basic_yield_context<Executor>)>::type>::type>(
-          declval<detail::initiate_spawn<Executor> >(),
+        result_of_t<F(basic_yield_context<Executor>)>>::type>(
+          declval<detail::initiate_spawn<Executor>>(),
           token, allocator_arg_t(),
-          BOOST_ASIO_MOVE_CAST(StackAllocator)(stack_allocator),
-          BOOST_ASIO_MOVE_CAST(F)(function))));
+          static_cast<StackAllocator&&>(stack_allocator),
+          static_cast<F&&>(function)));
 
 /// Start a new stackful coroutine that executes on a given execution context.
 /**
@@ -647,33 +628,27 @@ spawn(const Executor& ex, allocator_arg_t,
  */
 template <typename ExecutionContext, typename StackAllocator, typename F,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
-      typename result_of<F(basic_yield_context<
-        typename ExecutionContext::executor_type>)>::type>::type)
-          CompletionToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
-            typename ExecutionContext::executor_type)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken,
-    typename detail::spawn_signature<
-      typename result_of<F(basic_yield_context<
-        typename ExecutionContext::executor_type>)>::type>::type)
-spawn(ExecutionContext& ctx, allocator_arg_t,
-    BOOST_ASIO_MOVE_ARG(StackAllocator) stack_allocator,
-    BOOST_ASIO_MOVE_ARG(F) function,
-    BOOST_ASIO_MOVE_ARG(CompletionToken) token
-      BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
-        typename ExecutionContext::executor_type),
-    typename constraint<
+      result_of_t<F(basic_yield_context<
+        typename ExecutionContext::executor_type>)>>::type)
+          CompletionToken = default_completion_token_t<
+            typename ExecutionContext::executor_type>>
+auto spawn(ExecutionContext& ctx, allocator_arg_t,
+    StackAllocator&& stack_allocator, F&& function,
+    CompletionToken&& token
+      = default_completion_token_t<typename ExecutionContext::executor_type>(),
+    constraint_t<
       is_convertible<ExecutionContext&, execution_context&>::value
-    >::type = 0)
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    > = 0)
+  -> decltype(
     async_initiate<CompletionToken,
       typename detail::spawn_signature<
-        typename result_of<F(basic_yield_context<
-          typename ExecutionContext::executor_type>)>::type>::type>(
+        result_of_t<F(basic_yield_context<
+          typename ExecutionContext::executor_type>)>>::type>(
             declval<detail::initiate_spawn<
-              typename ExecutionContext::executor_type> >(),
+              typename ExecutionContext::executor_type>>(),
             token, allocator_arg_t(),
-            BOOST_ASIO_MOVE_CAST(StackAllocator)(stack_allocator),
-            BOOST_ASIO_MOVE_CAST(F)(function))));
+            static_cast<StackAllocator&&>(stack_allocator),
+            static_cast<F&&>(function)));
 
 /// Start a new stackful coroutine, inheriting the executor of another.
 /**
@@ -714,27 +689,22 @@ spawn(ExecutionContext& ctx, allocator_arg_t,
  */
 template <typename Executor, typename StackAllocator, typename F,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
-      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
-        CompletionToken BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken,
-    typename detail::spawn_signature<
-      typename result_of<F(basic_yield_context<Executor>)>::type>::type)
-spawn(const basic_yield_context<Executor>& ctx, allocator_arg_t,
-    BOOST_ASIO_MOVE_ARG(StackAllocator) stack_allocator,
-    BOOST_ASIO_MOVE_ARG(F) function,
-    BOOST_ASIO_MOVE_ARG(CompletionToken) token
-    BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
-  typename constraint<
-    is_executor<Executor>::value || execution::is_executor<Executor>::value
-  >::type = 0)
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
-  async_initiate<CompletionToken,
-    typename detail::spawn_signature<
-      typename result_of<F(basic_yield_context<Executor>)>::type>::type>(
-        declval<detail::initiate_spawn<Executor> >(),
-        token, allocator_arg_t(),
-        BOOST_ASIO_MOVE_CAST(StackAllocator)(stack_allocator),
-        BOOST_ASIO_MOVE_CAST(F)(function))));
+      result_of_t<F(basic_yield_context<Executor>)>>::type)
+        CompletionToken = default_completion_token_t<Executor>>
+auto spawn(const basic_yield_context<Executor>& ctx, allocator_arg_t,
+    StackAllocator&& stack_allocator, F&& function,
+    CompletionToken&& token = default_completion_token_t<Executor>(),
+    constraint_t<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    > = 0)
+  -> decltype(
+    async_initiate<CompletionToken,
+      typename detail::spawn_signature<
+        result_of_t<F(basic_yield_context<Executor>)>>::type>(
+          declval<detail::initiate_spawn<Executor>>(),
+          token, allocator_arg_t(),
+          static_cast<StackAllocator&&>(stack_allocator),
+          static_cast<F&&>(function)));
 
 #endif // defined(BOOST_ASIO_HAS_BOOST_CONTEXT_FIBER)
        //   || defined(GENERATING_DOCUMENTATION)
@@ -754,7 +724,7 @@ BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
  * @param attributes Boost.Coroutine attributes used to customise the coroutine.
  */
 template <typename Function>
-void spawn(BOOST_ASIO_MOVE_ARG(Function) function,
+void spawn(Function&& function,
     const boost::coroutines::attributes& attributes
       = boost::coroutines::attributes());
 
@@ -775,14 +745,14 @@ void spawn(BOOST_ASIO_MOVE_ARG(Function) function,
  * @param attributes Boost.Coroutine attributes used to customise the coroutine.
  */
 template <typename Handler, typename Function>
-void spawn(BOOST_ASIO_MOVE_ARG(Handler) handler,
-    BOOST_ASIO_MOVE_ARG(Function) function,
+void spawn(Handler&& handler, Function&& function,
     const boost::coroutines::attributes& attributes
       = boost::coroutines::attributes(),
-    typename constraint<
-      !is_executor<typename decay<Handler>::type>::value &&
-      !execution::is_executor<typename decay<Handler>::type>::value &&
-      !is_convertible<Handler&, execution_context&>::value>::type = 0);
+    constraint_t<
+      !is_executor<decay_t<Handler>>::value &&
+      !execution::is_executor<decay_t<Handler>>::value &&
+      !is_convertible<Handler&, execution_context&>::value
+    > = 0);
 
 /// (Deprecated: Use overloads with a completion token.) Start a new stackful
 /// coroutine, inheriting the execution context of another.
@@ -801,8 +771,7 @@ void spawn(BOOST_ASIO_MOVE_ARG(Handler) handler,
  * @param attributes Boost.Coroutine attributes used to customise the coroutine.
  */
 template <typename Executor, typename Function>
-void spawn(basic_yield_context<Executor> ctx,
-    BOOST_ASIO_MOVE_ARG(Function) function,
+void spawn(basic_yield_context<Executor> ctx, Function&& function,
     const boost::coroutines::attributes& attributes
       = boost::coroutines::attributes());
 
@@ -821,13 +790,12 @@ void spawn(basic_yield_context<Executor> ctx,
  * @param attributes Boost.Coroutine attributes used to customise the coroutine.
  */
 template <typename Function, typename Executor>
-void spawn(const Executor& ex,
-    BOOST_ASIO_MOVE_ARG(Function) function,
+void spawn(const Executor& ex, Function&& function,
     const boost::coroutines::attributes& attributes
       = boost::coroutines::attributes(),
-    typename constraint<
+    constraint_t<
       is_executor<Executor>::value || execution::is_executor<Executor>::value
-    >::type = 0);
+    > = 0);
 
 /// (Deprecated: Use overloads with a completion token.) Start a new stackful
 /// coroutine that executes on a given strand.
@@ -842,8 +810,7 @@ void spawn(const Executor& ex,
  * @param attributes Boost.Coroutine attributes used to customise the coroutine.
  */
 template <typename Function, typename Executor>
-void spawn(const strand<Executor>& ex,
-    BOOST_ASIO_MOVE_ARG(Function) function,
+void spawn(const strand<Executor>& ex, Function&& function,
     const boost::coroutines::attributes& attributes
       = boost::coroutines::attributes());
 
@@ -864,8 +831,7 @@ void spawn(const strand<Executor>& ex,
  * @param attributes Boost.Coroutine attributes used to customise the coroutine.
  */
 template <typename Function>
-void spawn(const boost::asio::io_context::strand& s,
-    BOOST_ASIO_MOVE_ARG(Function) function,
+void spawn(const boost::asio::io_context::strand& s, Function&& function,
     const boost::coroutines::attributes& attributes
       = boost::coroutines::attributes());
 
@@ -886,12 +852,12 @@ void spawn(const boost::asio::io_context::strand& s,
  * @param attributes Boost.Coroutine attributes used to customise the coroutine.
  */
 template <typename Function, typename ExecutionContext>
-void spawn(ExecutionContext& ctx,
-    BOOST_ASIO_MOVE_ARG(Function) function,
+void spawn(ExecutionContext& ctx, Function&& function,
     const boost::coroutines::attributes& attributes
       = boost::coroutines::attributes(),
-    typename constraint<is_convertible<
-      ExecutionContext&, execution_context&>::value>::type = 0);
+    constraint_t<
+      is_convertible<ExecutionContext&, execution_context&>::value
+    > = 0);
 
 #endif // defined(BOOST_ASIO_HAS_BOOST_COROUTINE)
        //   || defined(GENERATING_DOCUMENTATION)

data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/context.hpp

@@ -2,7 +2,7 @@
 // ssl/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)
@@ -47,7 +47,6 @@ public:
   /// Construct to take ownership of a native handle.
   BOOST_ASIO_DECL explicit context(native_handle_type native_handle);
 
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
   /// Move-construct a context from another.
   /**
    * This constructor moves an SSL context from one object to another.
@@ -73,7 +72,6 @@ public:
    * @li As a target for move-assignment.
    */
   BOOST_ASIO_DECL context& operator=(context&& other);
-#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Destructor.
   BOOST_ASIO_DECL ~context();

data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/context_base.hpp

@@ -2,7 +2,7 @@
 // ssl/context_base.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)

data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/buffered_handshake_op.hpp

@@ -2,7 +2,7 @@
 // ssl/detail/buffered_handshake_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)
@@ -30,7 +30,7 @@ template <typename ConstBufferSequence>
 class buffered_handshake_op
 {
 public:
-  static BOOST_ASIO_CONSTEXPR const char* tracking_name()
+  static constexpr const char* tracking_name()
   {
     return "ssl::stream<>::async_buffered_handshake";
   }
@@ -57,7 +57,7 @@ public:
       const boost::system::error_code& ec,
       const std::size_t& bytes_transferred) const
   {
-    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)(ec, bytes_transferred);
+    static_cast<Handler&&>(handler)(ec, bytes_transferred);
   }
 
 private:

data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/engine.hpp

@@ -2,7 +2,7 @@
 // ssl/detail/engine.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)
@@ -62,18 +62,14 @@ public:
   // Construct a new engine for an existing native SSL implementation.
   BOOST_ASIO_DECL explicit engine(SSL* ssl_impl);
 
-#if defined(BOOST_ASIO_HAS_MOVE)
   // Move construct from another engine.
-  BOOST_ASIO_DECL engine(engine&& other) BOOST_ASIO_NOEXCEPT;
-#endif // defined(BOOST_ASIO_HAS_MOVE)
+  BOOST_ASIO_DECL engine(engine&& other) noexcept;
 
   // Destructor.
   BOOST_ASIO_DECL ~engine();
 
-#if defined(BOOST_ASIO_HAS_MOVE)
   // Move assign from another engine.
-  BOOST_ASIO_DECL engine& operator=(engine&& other) BOOST_ASIO_NOEXCEPT;
-#endif // defined(BOOST_ASIO_HAS_MOVE)
+  BOOST_ASIO_DECL engine& operator=(engine&& other) noexcept;
 
   // Get the underlying implementation in the native type.
   BOOST_ASIO_DECL SSL* native_handle();

data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/detail/handshake_op.hpp

@@ -2,7 +2,7 @@
 // ssl/detail/handshake_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)
@@ -29,7 +29,7 @@ namespace detail {
 class handshake_op
 {
 public:
-  static BOOST_ASIO_CONSTEXPR const char* tracking_name()
+  static constexpr const char* tracking_name()
   {
     return "ssl::stream<>::async_handshake";
   }
@@ -52,7 +52,7 @@ public:
       const boost::system::error_code& ec,
       const std::size_t&) const
   {
-    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler)(ec);
+    static_cast<Handler&&>(handler)(ec);
   }
 
 private: