asio/impl/cancel_after.hpp

0001 //
0002 // impl/cancel_after.hpp
0003 // ~~~~~~~~~~~~~~~~~~~~~
0004 //
0005 // Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
0006 //
0007 // Distributed under the Boost Software License, Version 1.0. (See accompanying
0008 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0009 //
0010
0011 #ifndef BOOST_ASIO_IMPL_CANCEL_AFTER_HPP
0012 #define BOOST_ASIO_IMPL_CANCEL_AFTER_HPP
0013
0014 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
0015 # pragma once
0016 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
0017
0018 #include <boost/asio/detail/config.hpp>
0019 #include <boost/asio/associated_executor.hpp>
0020 #include <boost/asio/async_result.hpp>
0021 #include <boost/asio/detail/initiation_base.hpp>
0022 #include <boost/asio/detail/timed_cancel_op.hpp>
0023
0024 #include <boost/asio/detail/push_options.hpp>
0025
0026 namespace boost {
0027 namespace asio {
0028 namespace detail {
0029
0030 template <typename Initiation, typename Clock,
0031     typename WaitTraits, typename... Signatures>
0032 struct initiate_cancel_after : initiation_base<Initiation>
0033 {
0034   using initiation_base<Initiation>::initiation_base;
0035
0036   template <typename Handler, typename Rep, typename Period, typename... Args>
0037   void operator()(Handler&& handler,
0038       const chrono::duration<Rep, Period>& timeout,
0039       cancellation_type_t cancel_type, Args&&... args) &&
0040   {
0041     using op = detail::timed_cancel_op<decay_t<Handler>,
0042         basic_waitable_timer<Clock, WaitTraits>, Signatures...>;
0043
0044     non_const_lvalue<Handler> handler2(handler);
0045     typename op::ptr p = { boost::asio::detail::addressof(handler2.value),
0046         op::ptr::allocate(handler2.value), 0 };
0047     p.p = new (p.v) op(handler2.value,
0048         basic_waitable_timer<Clock, WaitTraits,
0049           typename Initiation::executor_type>(this->get_executor(), timeout),
0050         cancel_type);
0051
0052     op* o = p.p;
0053     p.v = p.p = 0;
0054     o->start(static_cast<Initiation&&>(*this), static_cast<Args&&>(args)...);
0055   }
0056
0057   template <typename Handler, typename Rep, typename Period, typename... Args>
0058   void operator()(Handler&& handler,
0059       const chrono::duration<Rep, Period>& timeout,
0060       cancellation_type_t cancel_type, Args&&... args) const &
0061   {
0062     using op = detail::timed_cancel_op<decay_t<Handler>,
0063         basic_waitable_timer<Clock, WaitTraits>, Signatures...>;
0064
0065     non_const_lvalue<Handler> handler2(handler);
0066     typename op::ptr p = { boost::asio::detail::addressof(handler2.value),
0067         op::ptr::allocate(handler2.value), 0 };
0068     p.p = new (p.v) op(handler2.value,
0069         basic_waitable_timer<Clock, WaitTraits,
0070           typename Initiation::executor_type>(this->get_executor(), timeout),
0071         cancel_type);
0072
0073     op* o = p.p;
0074     p.v = p.p = 0;
0075     o->start(static_cast<const Initiation&>(*this),
0076         static_cast<Args&&>(args)...);
0077   }
0078 };
0079
0080 template <typename Initiation, typename Clock,
0081     typename WaitTraits, typename Executor, typename... Signatures>
0082 struct initiate_cancel_after_timer : initiation_base<Initiation>
0083 {
0084   using initiation_base<Initiation>::initiation_base;
0085
0086   template <typename Handler, typename Rep, typename Period, typename... Args>
0087   void operator()(Handler&& handler,
0088       basic_waitable_timer<Clock, WaitTraits, Executor>* timer,
0089       const chrono::duration<Rep, Period>& timeout,
0090       cancellation_type_t cancel_type, Args&&... args) &&
0091   {
0092     using op = detail::timed_cancel_op<decay_t<Handler>,
0093         basic_waitable_timer<Clock, WaitTraits, Executor>&, Signatures...>;
0094
0095     non_const_lvalue<Handler> handler2(handler);
0096     typename op::ptr p = { boost::asio::detail::addressof(handler2.value),
0097         op::ptr::allocate(handler2.value), 0 };
0098     timer->expires_after(timeout);
0099     p.p = new (p.v) op(handler2.value, *timer, cancel_type);
0100
0101     op* o = p.p;
0102     p.v = p.p = 0;
0103     o->start(static_cast<Initiation&&>(*this), static_cast<Args&&>(args)...);
0104   }
0105
0106   template <typename Handler, typename Rep, typename Period, typename... Args>
0107   void operator()(Handler&& handler,
0108       basic_waitable_timer<Clock, WaitTraits, Executor>* timer,
0109       const chrono::duration<Rep, Period>& timeout,
0110       cancellation_type_t cancel_type, Args&&... args) const &
0111   {
0112     using op = detail::timed_cancel_op<decay_t<Handler>,
0113         basic_waitable_timer<Clock, WaitTraits, Executor>&, Signatures...>;
0114
0115     non_const_lvalue<Handler> handler2(handler);
0116     typename op::ptr p = { boost::asio::detail::addressof(handler2.value),
0117         op::ptr::allocate(handler2.value), 0 };
0118     timer->expires_after(timeout);
0119     p.p = new (p.v) op(handler2.value, *timer, cancel_type);
0120
0121     op* o = p.p;
0122     p.v = p.p = 0;
0123     o->start(static_cast<const Initiation&>(*this),
0124         static_cast<Args&&>(args)...);
0125   }
0126 };
0127
0128 } // namespace detail
0129
0130 #if !defined(GENERATING_DOCUMENTATION)
0131
0132 template <typename CompletionToken, typename Clock,
0133     typename WaitTraits, typename... Signatures>
0134 struct async_result<
0135     cancel_after_t<CompletionToken, Clock, WaitTraits>, Signatures...>
0136   : async_result<CompletionToken, Signatures...>
0137 {
0138   template <typename Initiation, typename RawCompletionToken, typename... Args>
0139   static auto initiate(Initiation&& initiation,
0140       RawCompletionToken&& token, Args&&... args)
0141     -> decltype(
0142       async_initiate<
0143         conditional_t<
0144           is_const<remove_reference_t<RawCompletionToken>>::value,
0145             const CompletionToken, CompletionToken>,
0146         Signatures...>(
0147           declval<detail::initiate_cancel_after<
0148             decay_t<Initiation>, Clock, WaitTraits, Signatures...>>(),
0149           token.token_, token.timeout_, token.cancel_type_,
0150           static_cast<Args&&>(args)...))
0151   {
0152     return async_initiate<
0153       conditional_t<
0154         is_const<remove_reference_t<RawCompletionToken>>::value,
0155           const CompletionToken, CompletionToken>,
0156       Signatures...>(
0157         detail::initiate_cancel_after<
0158           decay_t<Initiation>, Clock, WaitTraits, Signatures...>(
0159             static_cast<Initiation&&>(initiation)),
0160         token.token_, token.timeout_, token.cancel_type_,
0161         static_cast<Args&&>(args)...);
0162   }
0163 };
0164
0165 template <typename CompletionToken, typename Clock,
0166     typename WaitTraits, typename Executor, typename... Signatures>
0167 struct async_result<
0168     cancel_after_timer<CompletionToken, Clock, WaitTraits, Executor>,
0169     Signatures...>
0170   : async_result<CompletionToken, Signatures...>
0171 {
0172   template <typename Initiation, typename RawCompletionToken, typename... Args>
0173   static auto initiate(Initiation&& initiation,
0174       RawCompletionToken&& token, Args&&... args)
0175     -> decltype(
0176       async_initiate<
0177         conditional_t<
0178           is_const<remove_reference_t<RawCompletionToken>>::value,
0179             const CompletionToken, CompletionToken>,
0180         Signatures...>(
0181           declval<detail::initiate_cancel_after_timer<
0182             decay_t<Initiation>, Clock, WaitTraits, Executor, Signatures...>>(),
0183           token.token_, &token.timer_, token.timeout_,
0184           token.cancel_type_, static_cast<Args&&>(args)...))
0185   {
0186     return async_initiate<
0187       conditional_t<
0188         is_const<remove_reference_t<RawCompletionToken>>::value,
0189           const CompletionToken, CompletionToken>,
0190       Signatures...>(
0191         detail::initiate_cancel_after_timer<
0192           decay_t<Initiation>, Clock, WaitTraits, Executor, Signatures...>(
0193             static_cast<Initiation&&>(initiation)),
0194         token.token_, &token.timer_, token.timeout_,
0195         token.cancel_type_, static_cast<Args&&>(args)...);
0196   }
0197 };
0198
0199 template <typename Clock, typename WaitTraits, typename... Signatures>
0200 struct async_result<partial_cancel_after<Clock, WaitTraits>, Signatures...>
0201 {
0202   template <typename Initiation, typename RawCompletionToken, typename... Args>
0203   static auto initiate(Initiation&& initiation,
0204       RawCompletionToken&& token, Args&&... args)
0205     -> decltype(
0206       async_initiate<
0207         const cancel_after_t<
0208           default_completion_token_t<associated_executor_t<Initiation>>,
0209           Clock, WaitTraits>&,
0210         Signatures...>(
0211           static_cast<Initiation&&>(initiation),
0212           cancel_after_t<
0213             default_completion_token_t<associated_executor_t<Initiation>>,
0214             Clock, WaitTraits>(
0215               default_completion_token_t<associated_executor_t<Initiation>>{},
0216               token.timeout_, token.cancel_type_),
0217           static_cast<Args&&>(args)...))
0218   {
0219     return async_initiate<
0220       const cancel_after_t<
0221         default_completion_token_t<associated_executor_t<Initiation>>,
0222         Clock, WaitTraits>&,
0223       Signatures...>(
0224         static_cast<Initiation&&>(initiation),
0225         cancel_after_t<
0226           default_completion_token_t<associated_executor_t<Initiation>>,
0227           Clock, WaitTraits>(
0228             default_completion_token_t<associated_executor_t<Initiation>>{},
0229             token.timeout_, token.cancel_type_),
0230         static_cast<Args&&>(args)...);
0231   }
0232 };
0233
0234 template <typename Clock, typename WaitTraits,
0235     typename Executor, typename... Signatures>
0236 struct async_result<
0237     partial_cancel_after_timer<Clock, WaitTraits, Executor>, Signatures...>
0238 {
0239   template <typename Initiation, typename RawCompletionToken, typename... Args>
0240   static auto initiate(Initiation&& initiation,
0241       RawCompletionToken&& token, Args&&... args)
0242     -> decltype(
0243       async_initiate<Signatures...>(
0244         static_cast<Initiation&&>(initiation),
0245         cancel_after_timer<
0246           default_completion_token_t<associated_executor_t<Initiation>>,
0247           Clock, WaitTraits, Executor>(
0248             default_completion_token_t<associated_executor_t<Initiation>>{},
0249             token.timer_, token.timeout_, token.cancel_type_),
0250         static_cast<Args&&>(args)...))
0251   {
0252     return async_initiate<Signatures...>(
0253         static_cast<Initiation&&>(initiation),
0254         cancel_after_timer<
0255           default_completion_token_t<associated_executor_t<Initiation>>,
0256           Clock, WaitTraits, Executor>(
0257             default_completion_token_t<associated_executor_t<Initiation>>{},
0258             token.timer_, token.timeout_, token.cancel_type_),
0259         static_cast<Args&&>(args)...);
0260   }
0261 };
0262
0263 #endif // !defined(GENERATING_DOCUMENTATION)
0264
0265 } // namespace asio
0266 } // namespace boost
0267
0268 #include <boost/asio/detail/pop_options.hpp>
0269
0270 #endif // BOOST_ASIO_IMPL_CANCEL_AFTER_HPP