Namespaces
Variants
Actions

Standard library header <stop_token> (C++20)

From cppreference.com
< cpp‎ | header
 
 
Standard library headers
 

This header is part of the thread support library.

(C++20)
an interface for querying if a std::jthread cancellation request has been made
(class) [edit]
(C++20)
class representing a request to stop one or more std::jthread s
(class) [edit]
an interface for registering callbacks on std::jthread cancellation
(class template) [edit]
provides a stop token interface that a stop is never possible nor requested
(class) [edit]
a stop token that references stop state of its associated std::inplace_stop_source object
(class) [edit]
a stoppable-source that is the sole owner of the stop state
(class) [edit]
a stop callback for std::inplace_stop_token
(class template) [edit]

Alias templates

obtains the callback type for a given stop token type
(alias template)[edit]

Concepts

specifies the basic interface of stop tokens which allows queries for stop requests and whether the stop request is possible
(concept) [edit]
specifies a stop token that does not allow stopping
(concept) [edit]

Tags

a tag used for stop_source to indicate no associated stop-state upon construction
(tag)[edit]

[edit] Synopsis

namespace std {
 // stop token concepts
 template<class CallbackFn, class Token, class Init = CallbackFn>
 concept /*stoppable-callback-for*/ = /* see description */; // exposition only
 
 template<class Token>
 concept stoppable_token = /* see description */;
 
 template<class Token>
 concept unstoppable_token = /* see description */;
 
 template<class Source>
 concept /*stoppable-source*/ = /* see description */; // exposition only
 
 // class stop_token
 class stop_token;
 
 // class stop_source
 class stop_source;
 
 // no-shared-stop-state indicator
 struct nostopstate_t {
 explicit nostopstate_t() = default;
 };
 inline constexpr nostopstate_t nostopstate{};
 
 // class template stop_callback
 template<class Callback>
 class stop_callback;
 
 // class never_stop_token
 class never_stop_token;
 
 // class inplace_stop_token
 class inplace_stop_token;
 
 // class inplace_stop_source
 class inplace_stop_source;
 
 // class template inplace_stop_callback
 template<class CallbackFn>
 class inplace_stop_callback;
 
 template<class T, class CallbackFn>
 using stop_callback_for_t = T::template callback_type<CallbackFn>;
}

[edit] Stop token concepts

namespace std {
 template<class CallbackFn, class Token, class Init = CallbackFn>
 concept /*stoppable-callback-for*/ = // exposition only
 invocable<CallbackFn> &&
 constructible_from<CallbackFn, Init> &&
 requires { typename stop_callback_for_t<Token, CallbackFn>; } &&
 constructible_from<stop_callback_for_t<Token, CallbackFn>, const Token&, Init>;
 
 template<template<class> class>
 struct /*check-type-alias-exists*/; // exposition only
 
 template<class Token>
 concept stoppable_token = 
 requires (const Token tok) {
 typename /*check-type-alias-exists*/<Token::template callback_type>;
 { tok.stop_requested() } noexcept -> same_as<bool>;
 { tok.stop_possible() } noexcept -> same_as<bool>;
 { Token(tok) } noexcept; // see implicit expression variations
 } &&
 copyable<Token> &&
 equality_comparable<Token>;
 
 template<class Token>
 concept unstoppable_token = 
 stoppable_token<Token> &&
 requires (const Token tok) {
 requires bool_constant<(!tok.stop_possible())>::value;
 };
 
 template<class Source>
 concept /*stoppable-source*/ = // exposition only
 requires (Source& src, const Source csrc) {
 { csrc.get_token() } -> stoppable_token;
 { csrc.stop_possible() } noexcept -> same_as<bool>;
 { csrc.stop_requested() } noexcept -> same_as<bool>;
 { src.request_stop() } -> same_as<bool>;
 };
}

[edit] Class std::stop_token

namespace std {
 class stop_token {
 public:
 template<class CallbackFn>
 using callback_type = stop_callback<CallbackFn>;
 
 // constructors, copy, and assignment
 stop_token() noexcept = default;
 
 // member functions
 void swap(stop_token&) noexcept;
 
 // stop handling
 bool stop_requested() const noexcept;
 bool stop_possible() const noexcept;
 
 friend bool operator==(const stop_token& lhs, const stop_token& rhs) noexcept;
 friend void swap(stop_token& lhs, stop_token& rhs) noexcept;
 
 private:
 shared_ptr</*unspecified*/> stop_state_; // exposition only
 };
}

[edit] Class std::stop_source

namespace std {
 class stop_source {
 public:
 // constructors, copy, and assignment
 stop_source();
 explicit stop_source(nostopstate_t) noexcept {}
 
 // member functions
 void swap(stop_source&) noexcept;
 
 // stop handling
 stop_token get_token() const noexcept;
 bool stop_possible() const noexcept;
 bool stop_requested() const noexcept;
 bool request_stop() noexcept;
 
 friend bool
 operator==(const stop_source& lhs, const stop_source& rhs) noexcept;
 friend void swap(stop_source& lhs, stop_source& rhs) noexcept;
 
 private:
 shared_ptr</*unspecified*/> stop_state_; // exposition only
 };
}

[edit] Class template std::stop_callback

namespace std {
 template<class CallbackFn>
 class stop_callback {
 public:
 using callback_type = CallbackFn;
 
 // constructors and destructor
 template<class Init>
 explicit stop_callback(const stop_token& st, Init&& init)
 noexcept(is_nothrow_constructible_v<CallbackFn, Init>);
 template<class Init>
 explicit stop_callback(stop_token&& st, Init&& init)
 noexcept(is_nothrow_constructible_v<CallbackFn, Init>);
 ~stop_callback();
 
 stop_callback(const stop_callback&) = delete;
 stop_callback(stop_callback&&) = delete;
 stop_callback& operator=(const stop_callback&) = delete;
 stop_callback& operator=(stop_callback&&) = delete;
 
 private:
 CallbackFn callback_fn_; // exposition only
 };
 
 template<class CallbackFn>
 stop_callback(stop_token, CallbackFn) -> stop_callback<CallbackFn>;
}

[edit] Class template std::never_stop_token

namespace std {
 class never_stop_token {
 struct /*callback-type*/ { // exposition only
 explicit /*callback-type*/(never_stop_token, auto&&) noexcept {}
 };
 
 public:
 template<class>
 using callback_type = /*callback-type*/;
 
 static constexpr bool stop_requested() noexcept { return false; }
 static constexpr bool stop_posible() noexcept { return false; }
 
 bool operator==(const never_stop_token&) const = default;
 };
}

[edit] Class template std::inplace_stop_token

namespace std {
 class inplace_stop_token {
 public:
 template<class CallbackFn>
 using callback_type = inplace_stop_callback<CallbackFn>;
 
 inplace_stop_token() = default;
 bool operator==(const inplace_stop_token&) const = default;
 
 // member functions
 bool stop_requested() const noexcept;
 bool stop_possible() const noexcept;
 void swap(inplace_stop_token&) noexcept;
 
 private:
 const inplace_stop_source* stop_source_ = nullptr; // exposition only
 };
}

[edit] Class template std::inplace_stop_source

namespace std {
 class inplace_stop_source {
 // constructors, assignments, and destructor
 constexpr inplace_stop_source() noexcept;
 
 inplace_stop_source(inplace_stop_source&&) = delete;
 inplace_stop_source(const inplace_stop_source&) = delete;
 inplace_stop_source& operator=(inplace_stop_source&&) = delete;
 inplace_stop_source& operator=(const inplace_stop_source&) = delete;
 ~inplace_stop_source();
 
 // stop handling
 constexpr inplace_stop_token get_token() const noexcept;
 static constexpr bool stop_possible() noexcept { return true; }
 bool stop_requested() const noexcept;
 bool request_stop() noexcept;
 };
}

[edit] Class template std::inplace_stop_callback

namespace std {
 template<class CallbackFn>
 class inplace_stop_callback {
 public:
 using callback_type = CallbackFn;
 
 // constructors and destructor
 template<class Init>
 explicit inplace_stop_callback(inplace_stop_token st, Init&& init)
 noexcept(is_nothrow_constructible_v<CallbackFn, Init>);
 ~inplace_stop_callback();
 
 inplace_stop_callback(const inplace_stop_callback&) = delete;
 inplace_stop_callback(inplace_stop_callback&&) = delete;
 inplace_stop_callback& operator=(const inplace_stop_callback&) = delete;
 inplace_stop_callback& operator=(inplace_stop_callback&&) = delete;
 
 private:
 CallbackFn callback_fn_; // exposition only
 };
 
 template<class CallbackFn>
 inplace_stop_callback(inplace_stop_token, CallbackFn) 
 -> inplace_stop_callback<CallbackFn>;
}
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/header/stop_token&oldid=177423"

AltStyle によって変換されたページ (->オリジナル) /