1 // -*- C++ -*- 2 //===----------------------------------------------------------------------===// 3 // 4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5 // See https://llvm.org/LICENSE.txt for license information. 6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef _LIBCPP___STOP_TOKEN_STOP_CALLBACK_H 11 #define _LIBCPP___STOP_TOKEN_STOP_CALLBACK_H 12 13 #include <__availability> 14 #include <__concepts/constructible.h> 15 #include <__concepts/destructible.h> 16 #include <__concepts/invocable.h> 17 #include <__config> 18 #include <__stop_token/intrusive_shared_ptr.h> 19 #include <__stop_token/stop_state.h> 20 #include <__stop_token/stop_token.h> 21 #include <__type_traits/is_nothrow_constructible.h> 22 #include <__utility/forward.h> 23 #include <__utility/move.h> 24 25 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 26 # pragma GCC system_header 27 #endif 28 29 _LIBCPP_BEGIN_NAMESPACE_STD 30 31 #if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) 32 33 template <class _Callback> 34 class _LIBCPP_AVAILABILITY_SYNC stop_callback : private __stop_callback_base { 35 static_assert(invocable<_Callback>, 36 "Mandates: stop_callback is instantiated with an argument for the template parameter Callback that " 37 "satisfies invocable."); 38 static_assert(destructible<_Callback>, 39 "Mandates: stop_callback is instantiated with an argument for the template parameter Callback that " 40 "satisfies destructible."); 41 42 public: 43 using callback_type = _Callback; 44 45 template <class _Cb> 46 requires constructible_from<_Callback, _Cb> 47 _LIBCPP_HIDE_FROM_ABI explicit stop_callback(const stop_token& __st, 48 _Cb&& __cb) noexcept(is_nothrow_constructible_v<_Callback, _Cb>) 49 : stop_callback(__private_tag{}, __st.__state_, std::forward<_Cb>(__cb)) {} 50 51 template <class _Cb> 52 requires constructible_from<_Callback, _Cb> 53 _LIBCPP_HIDE_FROM_ABI explicit stop_callback(stop_token&& __st, 54 _Cb&& __cb) noexcept(is_nothrow_constructible_v<_Callback, _Cb>) 55 : stop_callback(__private_tag{}, std::move(__st.__state_), std::forward<_Cb>(__cb)) {} 56 57 _LIBCPP_HIDE_FROM_ABI ~stop_callback() { 58 if (__state_) { 59 __state_->__remove_callback(this); 60 } 61 } 62 63 stop_callback(const stop_callback&) = delete; 64 stop_callback(stop_callback&&) = delete; 65 stop_callback& operator=(const stop_callback&) = delete; 66 stop_callback& operator=(stop_callback&&) = delete; 67 68 private: 69 _LIBCPP_NO_UNIQUE_ADDRESS _Callback __callback_; 70 __intrusive_shared_ptr<__stop_state> __state_; 71 72 friend __stop_callback_base; 73 74 struct __private_tag {}; 75 76 template <class _StatePtr, class _Cb> 77 _LIBCPP_HIDE_FROM_ABI explicit stop_callback(__private_tag, _StatePtr&& __state, _Cb&& __cb) noexcept( 78 is_nothrow_constructible_v<_Callback, _Cb>) 79 : __stop_callback_base([](__stop_callback_base* __cb_base) noexcept { 80 // stop callback is supposed to only be called once 81 std::forward<_Callback>(static_cast<stop_callback*>(__cb_base)->__callback_)(); 82 }), 83 __callback_(std::forward<_Cb>(__cb)), 84 __state_() { 85 if (__state && __state->__add_callback(this)) { 86 // st.stop_requested() was false and this is successfully added to the linked list 87 __state_ = std::forward<_StatePtr>(__state); 88 } 89 } 90 }; 91 92 template <class _Callback> 93 _LIBCPP_AVAILABILITY_SYNC stop_callback(stop_token, _Callback) -> stop_callback<_Callback>; 94 95 #endif // _LIBCPP_STD_VER >= 20 96 97 _LIBCPP_END_NAMESPACE_STD 98 99 #endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) 100