[thread.stoptoken] - C++20 → C++23

Files changed (1) hide show

tmp/tmpr4r7h7sp/{from.md → to.md} +20 -15

tmp/tmpr4r7h7sp/{from.md → to.md} RENAMED Viewed

@@ -1,13 +1,13 @@
 ## Stop tokens <a id="thread.stoptoken">[[thread.stoptoken]]</a>
 ### Introduction <a id="thread.stoptoken.intro">[[thread.stoptoken.intro]]</a>
-This clause describes components that can be used to asynchonously
-request that an operation stops execution in a timely manner, typically
-because the result is no longer required. Such a request is called a
-*stop request*.
 `stop_source`, `stop_token`, and `stop_callback` implement semantics of
 shared ownership of a *stop state*. Any `stop_source`, `stop_token`, or
 `stop_callback` that shares ownership of the same stop state is an
 *associated* `stop_source`, `stop_token`, or `stop_callback`,
@@ -49,22 +49,24 @@ namespace std {
   struct nostopstate_t {
     explicit nostopstate_t() = default;
   };
   inline constexpr nostopstate_t nostopstate{};
-  // [stopcallback], class stop_callback
   template<class Callback>
     class stop_callback;
 }
 ```
 ### Class `stop_token` <a id="stoptoken">[[stoptoken]]</a>
 The class `stop_token` provides an interface for querying whether a stop
 request has been made (`stop_requested`) or can ever be made
-(`stop_possible`) using an associated `stop_source` object (
-[[stopsource]]). A `stop_token` can also be passed to a `stop_callback`
 [[stopcallback]] constructor to register a callback to be called when a
 stop request has been made from an associated `stop_source`.
 ``` cpp
 namespace std {
@@ -184,14 +186,16 @@ friend void swap(stop_token& x, stop_token& y) noexcept;
 *Effects:* Equivalent to: `x.swap(y)`.
 ### Class `stop_source` <a id="stopsource">[[stopsource]]</a>
 The class `stop_source` implements the semantics of making a stop
 request. A stop request made on a `stop_source` object is visible to all
-associated `stop_source` and `stop_token` ([[stoptoken]]) objects. Once
-a stop request has been made it cannot be withdrawn (a subsequent stop
 request has no effect).
 ``` cpp
 namespace std {
   // no-shared-stop-state indicator
@@ -235,12 +239,11 @@ stop_source();
 *Effects:* Initialises `*this` to have ownership of a new stop state.
 *Ensures:* `stop_possible()` is `true` and `stop_requested()` is
 `false`.
-*Throws:* `bad_alloc` if memory could not be allocated for the stop
-state.
 ``` cpp
 explicit stop_source(nostopstate_t) noexcept;
 ```
@@ -325,11 +328,11 @@ bool request_stop() noexcept;
 has received a stop request, and if not, makes a stop request. The
 determination and making of the stop request are an atomic
 read-modify-write operation [[intro.races]]. If the request was made,
 the callbacks registered by associated `stop_callback` objects are
 synchronously called. If an invocation of a callback exits via an
-exception then `terminate` is called [[except.terminate]].
 [*Note 1*: A stop request includes notifying all condition variables of
 type `condition_variable_any` temporarily registered during an
 interruptible wait [[thread.condvarany.intwait]]. — *end note*]
@@ -354,10 +357,12 @@ friend void swap(stop_source& x, stop_source& y) noexcept;
 *Effects:* Equivalent to: `x.swap(y)`.
 ### Class template `stop_callback` <a id="stopcallback">[[stopcallback]]</a>
 ``` cpp
 namespace std {
   template<class Callback>
   class stop_callback {
   public:
@@ -418,15 +423,15 @@ before the constructor returns. Otherwise, if `st` has ownership of a
 stop state, acquires shared ownership of that stop state and registers
 the callback with that stop state such that
 `std::forward<Callback>(callback)()` is evaluated by the first call to
 `request_stop()` on an associated `stop_source`.
-*Remarks:* If evaluating `std::forward<Callback>(callback)()` exits via
-an exception, then `terminate` is called [[except.terminate]].
 *Throws:* Any exception thrown by the initialization of `callback`.
 ``` cpp
 ~stop_callback();
 ```
 *Effects:* Unregisters the callback from the owned stop state, if any.

 ## Stop tokens <a id="thread.stoptoken">[[thread.stoptoken]]</a>
 ### Introduction <a id="thread.stoptoken.intro">[[thread.stoptoken.intro]]</a>
+Subclause [[thread.stoptoken]] describes components that can be used to
+asynchronously request that an operation stops execution in a timely
+manner, typically because the result is no longer required. Such a
+request is called a *stop request*.
 `stop_source`, `stop_token`, and `stop_callback` implement semantics of
 shared ownership of a *stop state*. Any `stop_source`, `stop_token`, or
 `stop_callback` that shares ownership of the same stop state is an
 *associated* `stop_source`, `stop_token`, or `stop_callback`,
   struct nostopstate_t {
     explicit nostopstate_t() = default;
   };
   inline constexpr nostopstate_t nostopstate{};
+  // [stopcallback], class template stop_callback
   template<class Callback>
     class stop_callback;
 }
 ```
 ### Class `stop_token` <a id="stoptoken">[[stoptoken]]</a>
+#### General <a id="stoptoken.general">[[stoptoken.general]]</a>
 The class `stop_token` provides an interface for querying whether a stop
 request has been made (`stop_requested`) or can ever be made
+(`stop_possible`) using an associated `stop_source` object
+[[stopsource]]. A `stop_token` can also be passed to a `stop_callback`
 [[stopcallback]] constructor to register a callback to be called when a
 stop request has been made from an associated `stop_source`.
 ``` cpp
 namespace std {
 *Effects:* Equivalent to: `x.swap(y)`.
 ### Class `stop_source` <a id="stopsource">[[stopsource]]</a>
+#### General <a id="stopsource.general">[[stopsource.general]]</a>
 The class `stop_source` implements the semantics of making a stop
 request. A stop request made on a `stop_source` object is visible to all
+associated `stop_source` and `stop_token` [[stoptoken]] objects. Once a
+stop request has been made it cannot be withdrawn (a subsequent stop
 request has no effect).
 ``` cpp
 namespace std {
   // no-shared-stop-state indicator
 *Effects:* Initialises `*this` to have ownership of a new stop state.
 *Ensures:* `stop_possible()` is `true` and `stop_requested()` is
 `false`.
+*Throws:* `bad_alloc` if memory cannot be allocated for the stop state.
 ``` cpp
 explicit stop_source(nostopstate_t) noexcept;
 ```
 has received a stop request, and if not, makes a stop request. The
 determination and making of the stop request are an atomic
 read-modify-write operation [[intro.races]]. If the request was made,
 the callbacks registered by associated `stop_callback` objects are
 synchronously called. If an invocation of a callback exits via an
+exception then `terminate` is invoked [[except.terminate]].
 [*Note 1*: A stop request includes notifying all condition variables of
 type `condition_variable_any` temporarily registered during an
 interruptible wait [[thread.condvarany.intwait]]. — *end note*]
 *Effects:* Equivalent to: `x.swap(y)`.
 ### Class template `stop_callback` <a id="stopcallback">[[stopcallback]]</a>
+#### General <a id="stopcallback.general">[[stopcallback.general]]</a>
 ``` cpp
 namespace std {
   template<class Callback>
   class stop_callback {
   public:
 stop state, acquires shared ownership of that stop state and registers
 the callback with that stop state such that
 `std::forward<Callback>(callback)()` is evaluated by the first call to
 `request_stop()` on an associated `stop_source`.
 *Throws:* Any exception thrown by the initialization of `callback`.
+*Remarks:* If evaluating `std::forward<Callback>(callback)()` exits via
+an exception, then `terminate` is invoked [[except.terminate]].
 ``` cpp
 ~stop_callback();
 ```
 *Effects:* Unregisters the callback from the owned stop state, if any.

Diff to HTML by rtfpessoa