• Log in

namespace std{// stop token conceptstemplate<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_tokenclass stop_token; // class stop_sourceclass stop_source; // no-shared-stop-state indicatorstruct nostopstate_t{explicit nostopstate_t()=default;};inlineconstexpr nostopstate_t nostopstate{}; // class template stop_callbacktemplate<class Callback>class stop_callback; // class never_stop_tokenclass never_stop_token; // class inplace_stop_tokenclass inplace_stop_token; // class inplace_stop_sourceclass inplace_stop_source; // class template inplace_stop_callbacktemplate<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 functionsvoid swap(stop_token&)noexcept; // stop handlingbool stop_requested()constnoexcept;bool stop_possible()constnoexcept; friendbool operator==(const stop_token& lhs,const stop_token& rhs)noexcept;friendvoid 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 functionsvoid swap(stop_source&)noexcept; // stop handling    stop_token get_token()constnoexcept;bool stop_possible()constnoexcept;bool stop_requested()constnoexcept;bool request_stop()noexcept; friendbool    operator==(const stop_source& lhs,const stop_source& rhs)noexcept;friendvoid 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 destructortemplate<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 onlyexplicit/*callback-type*/(never_stop_token,auto&&)noexcept{}}; public:template<class>using callback_type=/*callback-type*/; staticconstexprbool stop_requested()noexcept{returnfalse;}staticconstexprbool stop_posible()noexcept{returnfalse;} 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 functionsbool stop_requested()constnoexcept;bool stop_possible()constnoexcept;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 destructorconstexpr 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 handlingconstexpr inplace_stop_token get_token()constnoexcept;staticconstexprbool stop_possible()noexcept{returntrue;}bool stop_requested()constnoexcept;bool request_stop()noexcept;};}

namespace std{template<class CallbackFn>class inplace_stop_callback{public:using callback_type= CallbackFn; // constructors and destructortemplate<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>;}