passenger 6.0.22 → 6.0.24

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

@@ -16,10 +16,11 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/associated_executor.hpp>
 #include <boost/asio/associator.hpp>
 #include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/initiation_base.hpp>
+#include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/execution/executor.hpp>
 #include <boost/asio/execution_context.hpp>
 #include <boost/asio/is_executor.hpp>
@@ -395,6 +396,49 @@ private:
     uses_executor<T, Executor>::value> base_type;
 };
 
+/// A function object type that adapts a @ref completion_token to specify that
+/// the completion handler should have the supplied executor as its associated
+/// executor.
+/**
+ * May also be used directly as a completion token, in which case it adapts the
+ * asynchronous operation's default completion token (or boost::asio::deferred
+ * if no default is available).
+ */
+template <typename Executor>
+struct partial_executor_binder
+{
+  /// Constructor that specifies associated executor.
+  explicit partial_executor_binder(const Executor& ex)
+    : executor_(ex)
+  {
+  }
+
+  /// Adapt a @ref completion_token to specify that the completion handler
+  /// should have the executor as its associated executor.
+  template <typename CompletionToken>
+  BOOST_ASIO_NODISCARD inline
+  constexpr executor_binder<decay_t<CompletionToken>, Executor>
+  operator()(CompletionToken&& completion_token) const
+  {
+    return executor_binder<decay_t<CompletionToken>, Executor>(executor_arg_t(),
+        static_cast<CompletionToken&&>(completion_token), executor_);
+  }
+
+//private:
+  Executor executor_;
+};
+
+/// Create a partial completion token that associates an executor.
+template <typename Executor>
+BOOST_ASIO_NODISCARD inline partial_executor_binder<Executor>
+bind_executor(const Executor& ex,
+    constraint_t<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    > = 0)
+{
+  return partial_executor_binder<Executor>(ex);
+}
+
 /// Associate an object of type @c T with an executor of type @c Executor.
 template <typename Executor, typename T>
 BOOST_ASIO_NODISCARD inline executor_binder<decay_t<T>, Executor>
@@ -407,6 +451,20 @@ bind_executor(const Executor& ex, T&& t,
       executor_arg_t(), ex, static_cast<T&&>(t));
 }
 
+/// Create a partial completion token that associates an execution context's
+/// executor.
+template <typename ExecutionContext>
+BOOST_ASIO_NODISCARD inline partial_executor_binder<
+    typename ExecutionContext::executor_type>
+bind_executor(ExecutionContext& ctx,
+    constraint_t<
+      is_convertible<ExecutionContext&, execution_context&>::value
+    > = 0)
+{
+  return partial_executor_binder<typename ExecutionContext::executor_type>(
+      ctx.get_executor());
+}
+
 /// Associate an object of type @c T with an execution context's executor.
 template <typename ExecutionContext, typename T>
 BOOST_ASIO_NODISCARD inline executor_binder<decay_t<T>,
@@ -492,49 +550,48 @@ public:
   }
 
   template <typename Initiation>
-  struct init_wrapper
+  struct init_wrapper : detail::initiation_base<Initiation>
   {
-    template <typename Init>
-    init_wrapper(const Executor& ex, Init&& init)
-      : ex_(ex),
-        initiation_(static_cast<Init&&>(init))
-    {
-    }
+    using detail::initiation_base<Initiation>::initiation_base;
 
     template <typename Handler, typename... Args>
-    void operator()(Handler&& handler, Args&&... args)
+    void operator()(Handler&& handler, const Executor& e, Args&&... args) &&
     {
-      static_cast<Initiation&&>(initiation_)(
+      static_cast<Initiation&&>(*this)(
           executor_binder<decay_t<Handler>, Executor>(
-            executor_arg_t(), ex_, static_cast<Handler&&>(handler)),
+            executor_arg_t(), e, static_cast<Handler&&>(handler)),
           static_cast<Args&&>(args)...);
     }
 
     template <typename Handler, typename... Args>
-    void operator()(Handler&& handler, Args&&... args) const
+    void operator()(Handler&& handler,
+        const Executor& e, Args&&... args) const &
     {
-      initiation_(
+      static_cast<const Initiation&>(*this)(
           executor_binder<decay_t<Handler>, Executor>(
-            executor_arg_t(), ex_, static_cast<Handler&&>(handler)),
+            executor_arg_t(), e, static_cast<Handler&&>(handler)),
           static_cast<Args&&>(args)...);
     }
-
-    Executor ex_;
-    Initiation initiation_;
   };
 
   template <typename Initiation, typename RawCompletionToken, typename... Args>
   static auto initiate(Initiation&& initiation,
       RawCompletionToken&& token, Args&&... args)
     -> decltype(
-      async_initiate<T, Signature>(
-        declval<init_wrapper<decay_t<Initiation>>>(),
-        token.get(), static_cast<Args&&>(args)...))
+      async_initiate<
+        conditional_t<
+          is_const<remove_reference_t<RawCompletionToken>>::value, const T, T>,
+        Signature>(
+          declval<init_wrapper<decay_t<Initiation>>>(),
+          token.get(), token.get_executor(), static_cast<Args&&>(args)...))
   {
-    return async_initiate<T, Signature>(
+    return async_initiate<
+      conditional_t<
+        is_const<remove_reference_t<RawCompletionToken>>::value, const T, T>,
+      Signature>(
         init_wrapper<decay_t<Initiation>>(
-          token.get_executor(), static_cast<Initiation&&>(initiation)),
-        token.get(), static_cast<Args&&>(args)...);
+          static_cast<Initiation&&>(initiation)),
+        token.get(), token.get_executor(), static_cast<Args&&>(args)...);
   }
 
 private:
@@ -542,6 +599,31 @@ private:
   async_result& operator=(const async_result&) = delete;
 };
 
+template <typename Executor, typename... Signatures>
+struct async_result<partial_executor_binder<Executor>, Signatures...>
+{
+  template <typename Initiation, typename RawCompletionToken, typename... Args>
+  static auto initiate(Initiation&& initiation,
+      RawCompletionToken&& token, Args&&... args)
+    -> decltype(
+      async_initiate<Signatures...>(
+        static_cast<Initiation&&>(initiation),
+        executor_binder<
+          default_completion_token_t<associated_executor_t<Initiation>>,
+          Executor>(executor_arg_t(), token.executor_,
+            default_completion_token_t<associated_executor_t<Initiation>>{}),
+        static_cast<Args&&>(args)...))
+  {
+    return async_initiate<Signatures...>(
+        static_cast<Initiation&&>(initiation),
+        executor_binder<
+          default_completion_token_t<associated_executor_t<Initiation>>,
+          Executor>(executor_arg_t(), token.executor_,
+            default_completion_token_t<associated_executor_t<Initiation>>{}),
+        static_cast<Args&&>(args)...);
+  }
+};
+
 template <template <typename, typename> class Associator,
     typename T, typename Executor, typename DefaultCandidate>
 struct associator<Associator, executor_binder<T, Executor>, DefaultCandidate>

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

@@ -16,10 +16,12 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/associated_executor.hpp>
 #include <boost/asio/associated_immediate_executor.hpp>
 #include <boost/asio/associator.hpp>
 #include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/initiation_base.hpp>
+#include <boost/asio/detail/type_traits.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -366,6 +368,46 @@ private:
   T target_;
 };
 
+/// A function object type that adapts a @ref completion_token to specify that
+/// the completion handler should have the supplied executor as its associated
+/// immediate executor.
+/**
+ * May also be used directly as a completion token, in which case it adapts the
+ * asynchronous operation's default completion token (or boost::asio::deferred
+ * if no default is available).
+ */
+template <typename Executor>
+struct partial_immediate_executor_binder
+{
+  /// Constructor that specifies associated executor.
+  explicit partial_immediate_executor_binder(const Executor& ex)
+    : executor_(ex)
+  {
+  }
+
+  /// Adapt a @ref completion_token to specify that the completion handler
+  /// should have the executor as its associated immediate executor.
+  template <typename CompletionToken>
+  BOOST_ASIO_NODISCARD inline
+  constexpr immediate_executor_binder<decay_t<CompletionToken>, Executor>
+  operator()(CompletionToken&& completion_token) const
+  {
+    return immediate_executor_binder<decay_t<CompletionToken>, Executor>(
+        static_cast<CompletionToken&&>(completion_token), executor_);
+  }
+
+//private:
+  Executor executor_;
+};
+
+/// Create a partial completion token that associates an executor.
+template <typename Executor>
+BOOST_ASIO_NODISCARD inline partial_immediate_executor_binder<Executor>
+bind_immediate_executor(const Executor& ex)
+{
+  return partial_immediate_executor_binder<Executor>(ex);
+}
+
 /// Associate an object of type @c T with a immediate executor of type
 /// @c Executor.
 template <typename Executor, typename T>
@@ -450,52 +492,52 @@ public:
   }
 
   template <typename Initiation>
-  struct init_wrapper
+  struct init_wrapper : detail::initiation_base<Initiation>
   {
-    template <typename Init>
-    init_wrapper(const Executor& e, Init&& init)
-      : executor_(e),
-        initiation_(static_cast<Init&&>(init))
-    {
-    }
+    using detail::initiation_base<Initiation>::initiation_base;
 
     template <typename Handler, typename... Args>
-    void operator()(Handler&& handler, Args&&... args)
+    void operator()(Handler&& handler, const Executor& e, Args&&... args) &&
     {
-      static_cast<Initiation&&>(initiation_)(
+      static_cast<Initiation&&>(*this)(
           immediate_executor_binder<
             decay_t<Handler>, Executor>(
-              executor_, static_cast<Handler&&>(handler)),
+              e, static_cast<Handler&&>(handler)),
           static_cast<Args&&>(args)...);
     }
 
     template <typename Handler, typename... Args>
-    void operator()(Handler&& handler, Args&&... args) const
+    void operator()(Handler&& handler,
+        const Executor& e, Args&&... args) const &
     {
-      initiation_(
+      static_cast<const Initiation&>(*this)(
           immediate_executor_binder<
             decay_t<Handler>, Executor>(
-              executor_, static_cast<Handler&&>(handler)),
+              e, static_cast<Handler&&>(handler)),
           static_cast<Args&&>(args)...);
     }
-
-    Executor executor_;
-    Initiation initiation_;
   };
 
   template <typename Initiation, typename RawCompletionToken, typename... Args>
   static auto initiate(Initiation&& initiation,
       RawCompletionToken&& token, Args&&... args)
     -> decltype(
-      async_initiate<T, Signature>(
-        declval<init_wrapper<decay_t<Initiation>>>(),
-        token.get(), static_cast<Args&&>(args)...))
+      async_initiate<
+        conditional_t<
+          is_const<remove_reference_t<RawCompletionToken>>::value, const T, T>,
+        Signature>(
+          declval<init_wrapper<decay_t<Initiation>>>(),
+          token.get(), token.get_immediate_executor(),
+          static_cast<Args&&>(args)...))
   {
-    return async_initiate<T, Signature>(
+    return async_initiate<
+      conditional_t<
+        is_const<remove_reference_t<RawCompletionToken>>::value, const T, T>,
+      Signature>(
         init_wrapper<decay_t<Initiation>>(
-          token.get_immediate_executor(),
           static_cast<Initiation&&>(initiation)),
-        token.get(), static_cast<Args&&>(args)...);
+        token.get(), token.get_immediate_executor(),
+        static_cast<Args&&>(args)...);
   }
 
 private:
@@ -505,6 +547,31 @@ private:
   async_result<T, Signature> target_;
 };
 
+template <typename Executor, typename... Signatures>
+struct async_result<partial_immediate_executor_binder<Executor>, Signatures...>
+{
+  template <typename Initiation, typename RawCompletionToken, typename... Args>
+  static auto initiate(Initiation&& initiation,
+      RawCompletionToken&& token, Args&&... args)
+    -> decltype(
+      async_initiate<Signatures...>(
+        static_cast<Initiation&&>(initiation),
+        immediate_executor_binder<
+          default_completion_token_t<associated_executor_t<Initiation>>,
+          Executor>(token.executor_,
+            default_completion_token_t<associated_executor_t<Initiation>>{}),
+        static_cast<Args&&>(args)...))
+  {
+    return async_initiate<Signatures...>(
+        static_cast<Initiation&&>(initiation),
+        immediate_executor_binder<
+          default_completion_token_t<associated_executor_t<Initiation>>,
+          Executor>(token.executor_,
+            default_completion_token_t<associated_executor_t<Initiation>>{}),
+        static_cast<Args&&>(args)...);
+  }
+};
+
 template <template <typename, typename> class Associator,
     typename T, typename Executor, typename DefaultCandidate>
 struct associator<Associator,

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

@@ -2731,7 +2731,7 @@ struct literal<'0', 'X', Chars...> :
 } // namespace detail
 
 /// Literal operator for creating const_buffer objects from string literals.
-inline BOOST_ASIO_CONST_BUFFER operator"" _buf(const char* data, std::size_t n)
+inline BOOST_ASIO_CONST_BUFFER operator ""_buf(const char* data, std::size_t n)
 {
   return BOOST_ASIO_CONST_BUFFER(data, n);
 }
@@ -2739,7 +2739,7 @@ inline BOOST_ASIO_CONST_BUFFER operator"" _buf(const char* data, std::size_t n)
 /// Literal operator for creating const_buffer objects from unbounded binary or
 /// hexadecimal integer literals.
 template <char... Chars>
-inline BOOST_ASIO_CONST_BUFFER operator"" _buf()
+inline BOOST_ASIO_CONST_BUFFER operator ""_buf()
 {
   return BOOST_ASIO_CONST_BUFFER(
       +detail::literal<Chars...>::data,

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

@@ -130,7 +130,7 @@ public:
       service_->unregister_buffers();
 #endif // defined(BOOST_ASIO_HAS_IO_URING)
   }
-  
+
   /// Move assignment.
   buffer_registration& operator=(buffer_registration&& other) noexcept
   {

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

@@ -0,0 +1,303 @@
+//
+// cancel_after.hpp
+// ~~~~~~~~~~~~~~~~
+//
+// 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)
+//
+
+#ifndef BOOST_ASIO_CANCEL_AFTER_HPP
+#define BOOST_ASIO_CANCEL_AFTER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/basic_waitable_timer.hpp>
+#include <boost/asio/cancellation_type.hpp>
+#include <boost/asio/detail/chrono.hpp>
+#include <boost/asio/detail/type_traits.hpp>
+#include <boost/asio/wait_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// A @ref completion_token adapter that cancels an operation after a timeout.
+/**
+ * The cancel_after_t class is used to indicate that an asynchronous operation
+ * should be cancelled if not complete before the specified duration has
+ * elapsed.
+ */
+template <typename CompletionToken, typename Clock,
+    typename WaitTraits = boost::asio::wait_traits<Clock>>
+class cancel_after_t
+{
+public:
+  /// Constructor.
+  template <typename T>
+  cancel_after_t(T&& completion_token, const typename Clock::duration& timeout,
+      cancellation_type_t cancel_type = cancellation_type::terminal)
+    : token_(static_cast<T&&>(completion_token)),
+      timeout_(timeout),
+      cancel_type_(cancel_type)
+  {
+  }
+
+//private:
+  CompletionToken token_;
+  typename Clock::duration timeout_;
+  cancellation_type_t cancel_type_;
+};
+
+/// A @ref completion_token adapter that cancels an operation after a timeout.
+/**
+ * The cancel_after_timer class is used to indicate that an asynchronous
+ * operation should be cancelled if not complete before the specified duration
+ * has elapsed.
+ */
+template <typename CompletionToken, typename Clock,
+    typename WaitTraits = boost::asio::wait_traits<Clock>,
+    typename Executor = any_io_executor>
+class cancel_after_timer
+{
+public:
+  /// Constructor.
+  template <typename T>
+  cancel_after_timer(T&& completion_token,
+      basic_waitable_timer<Clock, WaitTraits, Executor>& timer,
+      const typename Clock::duration& timeout,
+      cancellation_type_t cancel_type = cancellation_type::terminal)
+    : token_(static_cast<T&&>(completion_token)),
+      timer_(timer),
+      timeout_(timeout),
+      cancel_type_(cancel_type)
+  {
+  }
+
+//private:
+  CompletionToken token_;
+  basic_waitable_timer<Clock, WaitTraits, Executor>& timer_;
+  typename Clock::duration timeout_;
+  cancellation_type_t cancel_type_;
+};
+
+/// A function object type that adapts a @ref completion_token to cancel an
+/// operation after a timeout.
+/**
+ * May also be used directly as a completion token, in which case it adapts the
+ * asynchronous operation's default completion token (or boost::asio::deferred
+ * if no default is available).
+ */
+template <typename Clock, typename WaitTraits = boost::asio::wait_traits<Clock>>
+class partial_cancel_after
+{
+public:
+  /// Constructor that specifies the timeout duration and cancellation type.
+  explicit partial_cancel_after(const typename Clock::duration& timeout,
+      cancellation_type_t cancel_type = cancellation_type::terminal)
+    : timeout_(timeout),
+      cancel_type_(cancel_type)
+  {
+  }
+
+  /// Adapt a @ref completion_token to specify that the completion handler
+  /// arguments should be combined into a single tuple argument.
+  template <typename CompletionToken>
+  BOOST_ASIO_NODISCARD inline
+  cancel_after_t<decay_t<CompletionToken>, Clock, WaitTraits>
+  operator()(CompletionToken&& completion_token) const
+  {
+    return cancel_after_t<decay_t<CompletionToken>, Clock, WaitTraits>(
+        static_cast<CompletionToken&&>(completion_token),
+        timeout_, cancel_type_);
+  }
+
+//private:
+  typename Clock::duration timeout_;
+  cancellation_type_t cancel_type_;
+};
+
+/// A function object type that adapts a @ref completion_token to cancel an
+/// operation after a timeout.
+/**
+ * May also be used directly as a completion token, in which case it adapts the
+ * asynchronous operation's default completion token (or boost::asio::deferred
+ * if no default is available).
+ */
+template <typename Clock, typename WaitTraits = boost::asio::wait_traits<Clock>,
+    typename Executor = any_io_executor>
+class partial_cancel_after_timer
+{
+public:
+  /// Constructor that specifies the timeout duration and cancellation type.
+  explicit partial_cancel_after_timer(
+      basic_waitable_timer<Clock, WaitTraits, Executor>& timer,
+      const typename Clock::duration& timeout,
+      cancellation_type_t cancel_type = cancellation_type::terminal)
+    : timer_(timer),
+      timeout_(timeout),
+      cancel_type_(cancel_type)
+  {
+  }
+
+  /// Adapt a @ref completion_token to specify that the completion handler
+  /// arguments should be combined into a single tuple argument.
+  template <typename CompletionToken>
+  BOOST_ASIO_NODISCARD inline
+  cancel_after_timer<decay_t<CompletionToken>, Clock, WaitTraits, Executor>
+  operator()(CompletionToken&& completion_token) const
+  {
+    return cancel_after_timer<decay_t<CompletionToken>,
+      Clock, WaitTraits, Executor>(
+        static_cast<CompletionToken&&>(completion_token),
+        timeout_, cancel_type_);
+  }
+
+//private:
+  basic_waitable_timer<Clock, WaitTraits, Executor>& timer_;
+  typename Clock::duration timeout_;
+  cancellation_type_t cancel_type_;
+};
+
+/// Create a partial completion token adapter that cancels an operation if not
+/// complete before the specified relative timeout has elapsed.
+/**
+ * @par Thread Safety
+ * When an asynchronous operation is used with cancel_after, a timer async_wait
+ * operation is performed in parallel to the main operation. If this parallel
+ * async_wait completes first, a cancellation request is emitted to cancel the
+ * main operation. Consequently, the application must ensure that the
+ * asynchronous operation is performed within an implicit or explicit strand.
+ */
+template <typename Rep, typename Period>
+BOOST_ASIO_NODISCARD inline partial_cancel_after<chrono::steady_clock>
+cancel_after(const chrono::duration<Rep, Period>& timeout,
+    cancellation_type_t cancel_type = cancellation_type::terminal)
+{
+  return partial_cancel_after<chrono::steady_clock>(timeout, cancel_type);
+}
+
+/// Create a partial completion token adapter that cancels an operation if not
+/// complete before the specified relative timeout has elapsed.
+/**
+ * @par Thread Safety
+ * When an asynchronous operation is used with cancel_after, a timer async_wait
+ * operation is performed in parallel to the main operation. If this parallel
+ * async_wait completes first, a cancellation request is emitted to cancel the
+ * main operation. Consequently, the application must ensure that the
+ * asynchronous operation is performed within an implicit or explicit strand.
+ */
+template <typename Clock, typename WaitTraits,
+    typename Executor, typename Rep, typename Period>
+BOOST_ASIO_NODISCARD inline
+partial_cancel_after_timer<Clock, WaitTraits, Executor>
+cancel_after(basic_waitable_timer<Clock, WaitTraits, Executor>& timer,
+    const chrono::duration<Rep, Period>& timeout,
+    cancellation_type_t cancel_type = cancellation_type::terminal)
+{
+  return partial_cancel_after_timer<Clock, WaitTraits, Executor>(
+      timer, timeout, cancel_type);
+}
+
+/// Adapt a @ref completion_token to cancel an operation if not complete before
+/// the specified relative timeout has elapsed.
+/**
+ * @par Thread Safety
+ * When an asynchronous operation is used with cancel_after, a timer async_wait
+ * operation is performed in parallel to the main operation. If this parallel
+ * async_wait completes first, a cancellation request is emitted to cancel the
+ * main operation. Consequently, the application must ensure that the
+ * asynchronous operation is performed within an implicit or explicit strand.
+ */
+template <typename Rep, typename Period, typename CompletionToken>
+BOOST_ASIO_NODISCARD inline
+cancel_after_t<decay_t<CompletionToken>, chrono::steady_clock>
+cancel_after(const chrono::duration<Rep, Period>& timeout,
+    CompletionToken&& completion_token)
+{
+  return cancel_after_t<decay_t<CompletionToken>, chrono::steady_clock>(
+      static_cast<CompletionToken&&>(completion_token),
+      timeout, cancellation_type::terminal);
+}
+
+/// Adapt a @ref completion_token to cancel an operation if not complete before
+/// the specified relative timeout has elapsed.
+/**
+ * @par Thread Safety
+ * When an asynchronous operation is used with cancel_after, a timer async_wait
+ * operation is performed in parallel to the main operation. If this parallel
+ * async_wait completes first, a cancellation request is emitted to cancel the
+ * main operation. Consequently, the application must ensure that the
+ * asynchronous operation is performed within an implicit or explicit strand.
+ */
+template <typename Rep, typename Period, typename CompletionToken>
+BOOST_ASIO_NODISCARD inline
+cancel_after_t<decay_t<CompletionToken>, chrono::steady_clock>
+cancel_after(const chrono::duration<Rep, Period>& timeout,
+    cancellation_type_t cancel_type, CompletionToken&& completion_token)
+{
+  return cancel_after_t<decay_t<CompletionToken>, chrono::steady_clock>(
+      static_cast<CompletionToken&&>(completion_token), timeout, cancel_type);
+}
+
+/// Adapt a @ref completion_token to cancel an operation if not complete before
+/// the specified relative timeout has elapsed.
+/**
+ * @par Thread Safety
+ * When an asynchronous operation is used with cancel_after, a timer async_wait
+ * operation is performed in parallel to the main operation. If this parallel
+ * async_wait completes first, a cancellation request is emitted to cancel the
+ * main operation. Consequently, the application must ensure that the
+ * asynchronous operation is performed within an implicit or explicit strand.
+ */
+template <typename Clock, typename WaitTraits, typename Executor,
+    typename Rep, typename Period, typename CompletionToken>
+BOOST_ASIO_NODISCARD inline
+cancel_after_timer<decay_t<CompletionToken>, Clock, WaitTraits, Executor>
+cancel_after(basic_waitable_timer<Clock, WaitTraits, Executor>& timer,
+    const chrono::duration<Rep, Period>& timeout,
+    CompletionToken&& completion_token)
+{
+  return cancel_after_timer<decay_t<CompletionToken>,
+    Clock, WaitTraits, Executor>(
+      static_cast<CompletionToken&&>(completion_token),
+      timer, timeout, cancellation_type::terminal);
+}
+
+/// Adapt a @ref completion_token to cancel an operation if not complete before
+/// the specified relative timeout has elapsed.
+/**
+ * @par Thread Safety
+ * When an asynchronous operation is used with cancel_after, a timer async_wait
+ * operation is performed in parallel to the main operation. If this parallel
+ * async_wait completes first, a cancellation request is emitted to cancel the
+ * main operation. Consequently, the application must ensure that the
+ * asynchronous operation is performed within an implicit or explicit strand.
+ */
+template <typename Clock, typename WaitTraits, typename Executor,
+    typename Rep, typename Period, typename CompletionToken>
+BOOST_ASIO_NODISCARD inline
+cancel_after_timer<decay_t<CompletionToken>, chrono::steady_clock>
+cancel_after(basic_waitable_timer<Clock, WaitTraits, Executor>& timer,
+    const chrono::duration<Rep, Period>& timeout,
+    cancellation_type_t cancel_type, CompletionToken&& completion_token)
+{
+  return cancel_after_timer<decay_t<CompletionToken>,
+    Clock, WaitTraits, Executor>(
+      static_cast<CompletionToken&&>(completion_token),
+      timer, timeout, cancel_type);
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/impl/cancel_after.hpp>
+
+#endif // BOOST_ASIO_CANCEL_AFTER_HPP