Standard library header  (C++20) (original) (raw)

This header is part of the thread support library.

[edit] Synopsis

namespace std { // stop token concepts template<class CallbackFn, class Token, class Init = CallbackFn> concept /stoppable-callback-for/ = /* see description /; // exposition only   template concept stoppable_token = / see description /;   template concept unstoppable_token = / see description /;   template 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 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 inplace_stop_callback;   template<class T, class CallbackFn> using stop_callback_for_t = T::template callback_type; }

[edit] Stop token concepts

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

[edit] Class std::stop_token

namespace std { class stop_token { public: template using callback_type = stop_callback;   // 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 stop_callback { public: using callback_type = CallbackFn;   // constructors and destructor template explicit stop_callback(const stop_token& st, Init&& init) noexcept(is_nothrow_constructible_v<CallbackFn, Init>); template 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 stop_callback(stop_token, CallbackFn) -> stop_callback; }

[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 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 using callback_type = inplace_stop_callback;   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 inplace_stop_callback { public: using callback_type = CallbackFn;   // constructors and destructor template 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 inplace_stop_callback(inplace_stop_token, CallbackFn) -> inplace_stop_callback; }