• Log in

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>;
}

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>;
 };
}

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
 };
}

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
 };
}

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>;
}

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;
 };
}

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
 };
}

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;
 };
}

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>;
}