passenger 6.0.20 → 6.0.21

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

@@ -2,7 +2,7 @@
 // impl/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)
@@ -19,6 +19,7 @@
 
 #if !defined(BOOST_ASIO_NO_TS_EXECUTORS)
 
+#include <new>
 #include <boost/asio/detail/atomic_count.hpp>
 #include <boost/asio/detail/global.hpp>
 #include <boost/asio/detail/memory.hpp>
@@ -48,7 +49,12 @@ public:
     return p;
   }
 
-  impl(const Executor& e, const Allocator& a) BOOST_ASIO_NOEXCEPT
+  static impl_base* create(std::nothrow_t, const Executor& e) noexcept
+  {
+    return new (std::nothrow) impl(e, std::allocator<void>());
+  }
+
+  impl(const Executor& e, const Allocator& a) noexcept
     : impl_base(false),
       ref_count_(1),
       executor_(e),
@@ -56,13 +62,13 @@ public:
   {
   }
 
-  impl_base* clone() const BOOST_ASIO_NOEXCEPT
+  impl_base* clone() const noexcept
   {
     detail::ref_count_up(ref_count_);
     return const_cast<impl_base*>(static_cast<const impl_base*>(this));
   }
 
-  void destroy() BOOST_ASIO_NOEXCEPT
+  void destroy() noexcept
   {
     if (detail::ref_count_down(ref_count_))
     {
@@ -73,52 +79,52 @@ public:
     }
   }
 
-  void on_work_started() BOOST_ASIO_NOEXCEPT
+  void on_work_started() noexcept
   {
     executor_.on_work_started();
   }
 
-  void on_work_finished() BOOST_ASIO_NOEXCEPT
+  void on_work_finished() noexcept
   {
     executor_.on_work_finished();
   }
 
-  execution_context& context() BOOST_ASIO_NOEXCEPT
+  execution_context& context() noexcept
   {
     return executor_.context();
   }
 
-  void dispatch(BOOST_ASIO_MOVE_ARG(function) f)
+  void dispatch(function&& f)
   {
-    executor_.dispatch(BOOST_ASIO_MOVE_CAST(function)(f), allocator_);
+    executor_.dispatch(static_cast<function&&>(f), allocator_);
   }
 
-  void post(BOOST_ASIO_MOVE_ARG(function) f)
+  void post(function&& f)
   {
-    executor_.post(BOOST_ASIO_MOVE_CAST(function)(f), allocator_);
+    executor_.post(static_cast<function&&>(f), allocator_);
   }
 
-  void defer(BOOST_ASIO_MOVE_ARG(function) f)
+  void defer(function&& f)
   {
-    executor_.defer(BOOST_ASIO_MOVE_CAST(function)(f), allocator_);
+    executor_.defer(static_cast<function&&>(f), allocator_);
   }
 
-  type_id_result_type target_type() const BOOST_ASIO_NOEXCEPT
+  type_id_result_type target_type() const noexcept
   {
     return type_id<Executor>();
   }
 
-  void* target() BOOST_ASIO_NOEXCEPT
+  void* target() noexcept
   {
     return &executor_;
   }
 
-  const void* target() const BOOST_ASIO_NOEXCEPT
+  const void* target() const noexcept
   {
     return &executor_;
   }
 
-  bool equals(const impl_base* e) const BOOST_ASIO_NOEXCEPT
+  bool equals(const impl_base* e) const noexcept
   {
     if (this == e)
       return true;
@@ -165,7 +171,12 @@ public:
   static impl_base* create(const system_executor&,
       const Allocator& = Allocator())
   {
-    return &detail::global<impl<system_executor, std::allocator<void> > >();
+    return &detail::global<impl<system_executor, std::allocator<void>> >();
+  }
+
+  static impl_base* create(std::nothrow_t, const system_executor&) noexcept
+  {
+    return &detail::global<impl<system_executor, std::allocator<void>> >();
   }
 
   impl()
@@ -173,64 +184,64 @@ public:
   {
   }
 
-  impl_base* clone() const BOOST_ASIO_NOEXCEPT
+  impl_base* clone() const noexcept
   {
     return const_cast<impl_base*>(static_cast<const impl_base*>(this));
   }
 
-  void destroy() BOOST_ASIO_NOEXCEPT
+  void destroy() noexcept
   {
   }
 
-  void on_work_started() BOOST_ASIO_NOEXCEPT
+  void on_work_started() noexcept
   {
     executor_.on_work_started();
   }
 
-  void on_work_finished() BOOST_ASIO_NOEXCEPT
+  void on_work_finished() noexcept
   {
     executor_.on_work_finished();
   }
 
-  execution_context& context() BOOST_ASIO_NOEXCEPT
+  execution_context& context() noexcept
   {
     return executor_.context();
   }
 
-  void dispatch(BOOST_ASIO_MOVE_ARG(function) f)
+  void dispatch(function&& f)
   {
-    executor_.dispatch(BOOST_ASIO_MOVE_CAST(function)(f),
+    executor_.dispatch(static_cast<function&&>(f),
         std::allocator<void>());
   }
 
-  void post(BOOST_ASIO_MOVE_ARG(function) f)
+  void post(function&& f)
   {
-    executor_.post(BOOST_ASIO_MOVE_CAST(function)(f),
+    executor_.post(static_cast<function&&>(f),
         std::allocator<void>());
   }
 
-  void defer(BOOST_ASIO_MOVE_ARG(function) f)
+  void defer(function&& f)
   {
-    executor_.defer(BOOST_ASIO_MOVE_CAST(function)(f),
+    executor_.defer(static_cast<function&&>(f),
         std::allocator<void>());
   }
 
-  type_id_result_type target_type() const BOOST_ASIO_NOEXCEPT
+  type_id_result_type target_type() const noexcept
   {
     return type_id<system_executor>();
   }
 
-  void* target() BOOST_ASIO_NOEXCEPT
+  void* target() noexcept
   {
     return &executor_;
   }
 
-  const void* target() const BOOST_ASIO_NOEXCEPT
+  const void* target() const noexcept
   {
     return &executor_;
   }
 
-  bool equals(const impl_base* e) const BOOST_ASIO_NOEXCEPT
+  bool equals(const impl_base* e) const noexcept
   {
     return this == e;
   }
@@ -241,7 +252,13 @@ private:
 
 template <typename Executor>
 executor::executor(Executor e)
-  : impl_(impl<Executor, std::allocator<void> >::create(e))
+  : impl_(impl<Executor, std::allocator<void>>::create(e))
+{
+}
+
+template <typename Executor>
+executor::executor(std::nothrow_t, Executor e) noexcept
+  : impl_(impl<Executor, std::allocator<void>>::create(std::nothrow, e))
 {
 }
 
@@ -252,39 +269,39 @@ executor::executor(allocator_arg_t, const Allocator& a, Executor e)
 }
 
 template <typename Function, typename Allocator>
-void executor::dispatch(BOOST_ASIO_MOVE_ARG(Function) f,
+void executor::dispatch(Function&& f,
     const Allocator& a) const
 {
   impl_base* i = get_impl();
   if (i->fast_dispatch_)
-    system_executor().dispatch(BOOST_ASIO_MOVE_CAST(Function)(f), a);
+    system_executor().dispatch(static_cast<Function&&>(f), a);
   else
-    i->dispatch(function(BOOST_ASIO_MOVE_CAST(Function)(f), a));
+    i->dispatch(function(static_cast<Function&&>(f), a));
 }
 
 template <typename Function, typename Allocator>
-void executor::post(BOOST_ASIO_MOVE_ARG(Function) f,
+void executor::post(Function&& f,
     const Allocator& a) const
 {
-  get_impl()->post(function(BOOST_ASIO_MOVE_CAST(Function)(f), a));
+  get_impl()->post(function(static_cast<Function&&>(f), a));
 }
 
 template <typename Function, typename Allocator>
-void executor::defer(BOOST_ASIO_MOVE_ARG(Function) f,
+void executor::defer(Function&& f,
     const Allocator& a) const
 {
-  get_impl()->defer(function(BOOST_ASIO_MOVE_CAST(Function)(f), a));
+  get_impl()->defer(function(static_cast<Function&&>(f), a));
 }
 
 template <typename Executor>
-Executor* executor::target() BOOST_ASIO_NOEXCEPT
+Executor* executor::target() noexcept
 {
   return impl_ && impl_->target_type() == type_id<Executor>()
     ? static_cast<Executor*>(impl_->target()) : 0;
 }
 
 template <typename Executor>
-const Executor* executor::target() const BOOST_ASIO_NOEXCEPT
+const Executor* executor::target() const noexcept
 {
   return impl_ && impl_->target_type() == type_id<Executor>()
     ? static_cast<Executor*>(impl_->target()) : 0;

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

@@ -2,7 +2,7 @@
 // impl/executor.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)
@@ -26,11 +26,11 @@
 namespace boost {
 namespace asio {
 
-bad_executor::bad_executor() BOOST_ASIO_NOEXCEPT
+bad_executor::bad_executor() noexcept
 {
 }
 
-const char* bad_executor::what() const BOOST_ASIO_NOEXCEPT_OR_NOTHROW
+const char* bad_executor::what() const noexcept
 {
   return "bad executor";
 }

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

@@ -2,7 +2,7 @@
 // impl/io_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)
@@ -51,13 +51,11 @@ inline detail::io_context_impl& use_service<detail::io_context_impl>(
 #endif // !defined(GENERATING_DOCUMENTATION)
 
 inline io_context::executor_type
-io_context::get_executor() BOOST_ASIO_NOEXCEPT
+io_context::get_executor() noexcept
 {
   return executor_type(*this);
 }
 
-#if defined(BOOST_ASIO_HAS_CHRONO)
-
 template <typename Rep, typename Period>
 std::size_t io_context::run_for(
     const chrono::duration<Rep, Period>& rel_time)
@@ -109,8 +107,6 @@ std::size_t io_context::run_one_until(
   return 0;
 }
 
-#endif // defined(BOOST_ASIO_HAS_CHRONO)
-
 #if !defined(BOOST_ASIO_NO_DEPRECATED)
 
 inline void io_context::reset()
@@ -121,7 +117,7 @@ inline void io_context::reset()
 struct io_context::initiate_dispatch
 {
   template <typename LegacyCompletionHandler>
-  void operator()(BOOST_ASIO_MOVE_ARG(LegacyCompletionHandler) handler,
+  void operator()(LegacyCompletionHandler&& handler,
       io_context* self) const
   {
     // If you get an error on the following line it means that your handler does
@@ -133,14 +129,13 @@ struct io_context::initiate_dispatch
     if (self->impl_.can_dispatch())
     {
       detail::fenced_block b(detail::fenced_block::full);
-      boost_asio_handler_invoke_helpers::invoke(
-          handler2.value, handler2.value);
+      static_cast<decay_t<LegacyCompletionHandler>&&>(handler2.value)();
     }
     else
     {
       // Allocate and construct an operation to wrap the handler.
       typedef detail::completion_handler<
-        typename decay<LegacyCompletionHandler>::type, executor_type> op;
+        decay_t<LegacyCompletionHandler>, executor_type> op;
       typename op::ptr p = { detail::addressof(handler2.value),
         op::ptr::allocate(handler2.value), 0 };
       p.p = new (p.v) op(handler2.value, self->get_executor());
@@ -155,11 +150,10 @@ struct io_context::initiate_dispatch
 };
 
 template <typename LegacyCompletionHandler>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(LegacyCompletionHandler, void ())
-io_context::dispatch(BOOST_ASIO_MOVE_ARG(LegacyCompletionHandler) handler)
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+auto io_context::dispatch(LegacyCompletionHandler&& handler)
+  -> decltype(
     async_initiate<LegacyCompletionHandler, void ()>(
-        declval<initiate_dispatch>(), handler, this)))
+      declval<initiate_dispatch>(), handler, this))
 {
   return async_initiate<LegacyCompletionHandler, void ()>(
       initiate_dispatch(), handler, this);
@@ -168,7 +162,7 @@ io_context::dispatch(BOOST_ASIO_MOVE_ARG(LegacyCompletionHandler) handler)
 struct io_context::initiate_post
 {
   template <typename LegacyCompletionHandler>
-  void operator()(BOOST_ASIO_MOVE_ARG(LegacyCompletionHandler) handler,
+  void operator()(LegacyCompletionHandler&& handler,
       io_context* self) const
   {
     // If you get an error on the following line it means that your handler does
@@ -183,7 +177,7 @@ struct io_context::initiate_post
 
     // Allocate and construct an operation to wrap the handler.
     typedef detail::completion_handler<
-      typename decay<LegacyCompletionHandler>::type, executor_type> op;
+      decay_t<LegacyCompletionHandler>, executor_type> op;
     typename op::ptr p = { detail::addressof(handler2.value),
         op::ptr::allocate(handler2.value), 0 };
     p.p = new (p.v) op(handler2.value, self->get_executor());
@@ -197,11 +191,10 @@ struct io_context::initiate_post
 };
 
 template <typename LegacyCompletionHandler>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(LegacyCompletionHandler, void ())
-io_context::post(BOOST_ASIO_MOVE_ARG(LegacyCompletionHandler) handler)
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+auto io_context::post(LegacyCompletionHandler&& handler)
+  -> decltype(
     async_initiate<LegacyCompletionHandler, void ()>(
-        declval<initiate_post>(), handler, this)))
+      declval<initiate_post>(), handler, this))
 {
   return async_initiate<LegacyCompletionHandler, void ()>(
       initiate_post(), handler, this);
@@ -223,7 +216,7 @@ io_context::wrap(Handler handler)
 template <typename Allocator, uintptr_t Bits>
 io_context::basic_executor_type<Allocator, Bits>&
 io_context::basic_executor_type<Allocator, Bits>::operator=(
-    const basic_executor_type& other) BOOST_ASIO_NOEXCEPT
+    const basic_executor_type& other) noexcept
 {
   if (this != &other)
   {
@@ -241,11 +234,10 @@ io_context::basic_executor_type<Allocator, Bits>::operator=(
   return *this;
 }
 
-#if defined(BOOST_ASIO_HAS_MOVE)
 template <typename Allocator, uintptr_t Bits>
 io_context::basic_executor_type<Allocator, Bits>&
 io_context::basic_executor_type<Allocator, Bits>::operator=(
-    basic_executor_type&& other) BOOST_ASIO_NOEXCEPT
+    basic_executor_type&& other) noexcept
 {
   if (this != &other)
   {
@@ -261,11 +253,10 @@ io_context::basic_executor_type<Allocator, Bits>::operator=(
   }
   return *this;
 }
-#endif // defined(BOOST_ASIO_HAS_MOVE)
 
 template <typename Allocator, uintptr_t Bits>
 inline bool io_context::basic_executor_type<Allocator,
-    Bits>::running_in_this_thread() const BOOST_ASIO_NOEXCEPT
+    Bits>::running_in_this_thread() const noexcept
 {
   return context_ptr()->impl_.can_dispatch();
 }
@@ -273,36 +264,32 @@ inline bool io_context::basic_executor_type<Allocator,
 template <typename Allocator, uintptr_t Bits>
 template <typename Function>
 void io_context::basic_executor_type<Allocator, Bits>::execute(
-    BOOST_ASIO_MOVE_ARG(Function) f) const
+    Function&& f) 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 && context_ptr()->impl_.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 (...)
     {
       context_ptr()->impl_.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.
@@ -310,7 +297,7 @@ void io_context::basic_executor_type<Allocator, Bits>::execute(
   typename op::ptr p = {
       detail::addressof(static_cast<const Allocator&>(*this)),
       op::ptr::allocate(static_cast<const Allocator&>(*this)), 0 };
-  p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(f),
+  p.p = new (p.v) op(static_cast<Function&&>(f),
       static_cast<const Allocator&>(*this));
 
   BOOST_ASIO_HANDLER_CREATION((*context_ptr(), *p.p,
@@ -324,21 +311,21 @@ void io_context::basic_executor_type<Allocator, Bits>::execute(
 #if !defined(BOOST_ASIO_NO_TS_EXECUTORS)
 template <typename Allocator, uintptr_t Bits>
 inline io_context& io_context::basic_executor_type<
-    Allocator, Bits>::context() const BOOST_ASIO_NOEXCEPT
+    Allocator, Bits>::context() const noexcept
 {
   return *context_ptr();
 }
 
 template <typename Allocator, uintptr_t Bits>
 inline void io_context::basic_executor_type<Allocator,
-    Bits>::on_work_started() const BOOST_ASIO_NOEXCEPT
+    Bits>::on_work_started() const noexcept
 {
   context_ptr()->impl_.work_started();
 }
 
 template <typename Allocator, uintptr_t Bits>
 inline void io_context::basic_executor_type<Allocator,
-    Bits>::on_work_finished() const BOOST_ASIO_NOEXCEPT
+    Bits>::on_work_finished() const noexcept
 {
   context_ptr()->impl_.work_finished();
 }
@@ -346,18 +333,18 @@ inline void io_context::basic_executor_type<Allocator,
 template <typename Allocator, uintptr_t Bits>
 template <typename Function, typename OtherAllocator>
 void io_context::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 (context_ptr()->impl_.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;
   }
 
@@ -365,7 +352,7 @@ void io_context::basic_executor_type<Allocator, Bits>::dispatch(
   typedef detail::executor_op<function_type,
       OtherAllocator, detail::operation> 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((*context_ptr(), *p.p,
         "io_context", context_ptr(), 0, "dispatch"));
@@ -377,15 +364,13 @@ void io_context::basic_executor_type<Allocator, Bits>::dispatch(
 template <typename Allocator, uintptr_t Bits>
 template <typename Function, typename OtherAllocator>
 void io_context::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;
-
   // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type,
+  typedef detail::executor_op<decay_t<Function>,
       OtherAllocator, detail::operation> 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((*context_ptr(), *p.p,
         "io_context", context_ptr(), 0, "post"));
@@ -397,15 +382,13 @@ void io_context::basic_executor_type<Allocator, Bits>::post(
 template <typename Allocator, uintptr_t Bits>
 template <typename Function, typename OtherAllocator>
 void io_context::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;
-
   // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type,
+  typedef detail::executor_op<decay_t<Function>,
       OtherAllocator, detail::operation> 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((*context_ptr(), *p.p,
         "io_context", context_ptr(), 0, "defer"));

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

@@ -2,7 +2,7 @@
 // impl/io_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)

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

@@ -2,7 +2,7 @@
 // impl/multiple_exceptions.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)
@@ -23,15 +23,13 @@
 namespace boost {
 namespace asio {
 
-#if defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR)
-
 multiple_exceptions::multiple_exceptions(
-    std::exception_ptr first) BOOST_ASIO_NOEXCEPT
-  : first_(BOOST_ASIO_MOVE_CAST(std::exception_ptr)(first))
+    std::exception_ptr first) noexcept
+  : first_(static_cast<std::exception_ptr&&>(first))
 {
 }
 
-const char* multiple_exceptions::what() const BOOST_ASIO_NOEXCEPT_OR_NOTHROW
+const char* multiple_exceptions::what() const noexcept
 {
   return "multiple exceptions";
 }
@@ -41,8 +39,6 @@ std::exception_ptr multiple_exceptions::first_exception() const
   return first_;
 }
 
-#endif // defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR)
-
 } // namespace asio
 } // namespace boost