[thread.condition.condvar] - C++20 → C++23

Files changed (1) hide show

tmp/tmpk9fgx25c/{from.md → to.md} +45 -45

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

@@ -55,18 +55,18 @@ required [[thread.req.exception]].
 ~condition_variable();
 ```
 *Preconditions:* There is no thread blocked on `*this`.
-[*Note 1*: That is, all threads have been notified; they could
 subsequently block on the lock specified in the wait. This relaxes the
 usual rules, which would have required all wait calls to happen before
 destruction. Only the notification to unblock the wait needs to happen
-before destruction. The user should take care to ensure that no threads
-wait on `*this` once the destructor has been started, especially when
-the waiting threads are calling the wait functions in a loop or using
-the overloads of `wait`, `wait_for`, or `wait_until` that take a
 predicate. — *end note*]
 ``` cpp
 void notify_one() noexcept;
 ```
@@ -98,21 +98,21 @@ locked by the calling thread, and either
 - When unblocked, calls `lock.lock()` (possibly blocking on the lock),
   then returns.
 - The function will unblock when signaled by a call to `notify_one()` or
   a call to `notify_all()`, or spuriously.
-*Remarks:* If the function fails to meet the postcondition,
-`terminate()` is called [[except.terminate]].
-[*Note 2*: This can happen if the re-locking of the mutex throws an
-exception. — *end note*]
 *Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread.
 *Throws:* Nothing.
 ``` cpp
 template<class Predicate>
   void wait(unique_lock<mutex>& lock, Predicate pred);
 ```
@@ -129,21 +129,21 @@ locked by the calling thread, and either
 ``` cpp
 while (!pred())
   wait(lock);
 ```
-*Remarks:* If the function fails to meet the postcondition,
-`terminate()` is called [[except.terminate]].
-[*Note 3*: This can happen if the re-locking of the mutex throws an
-exception. — *end note*]
 *Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread.
 *Throws:* Any exception thrown by `pred`.
 ``` cpp
 template<class Clock, class Duration>
   cv_status wait_until(unique_lock<mutex>& lock,
                        const chrono::time_point<Clock, Duration>& abs_time);
 ```
@@ -165,25 +165,25 @@ locked by the calling thread, and either
   call to `notify_all()`, expiration of the absolute
   timeout [[thread.req.timing]] specified by `abs_time`, or spuriously.
 - If the function exits via an exception, `lock.lock()` is called prior
   to exiting the function.
-*Remarks:* If the function fails to meet the postcondition,
-`terminate()` is called [[except.terminate]].
-[*Note 4*: This can happen if the re-locking of the mutex throws an
-exception. — *end note*]
 *Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread.
 *Returns:* `cv_status::timeout` if the absolute
 timeout [[thread.req.timing]] specified by `abs_time` expired, otherwise
 `cv_status::no_timeout`.
 *Throws:* Timeout-related exceptions [[thread.req.timing]].
 ``` cpp
 template<class Rep, class Period>
   cv_status wait_for(unique_lock<mutex>& lock,
                      const chrono::duration<Rep, Period>& rel_time);
 ```
@@ -200,25 +200,25 @@ locked by the calling thread, and either
 ``` cpp
 return wait_until(lock, chrono::steady_clock::now() + rel_time);
 ```
 *Returns:* `cv_status::timeout` if the relative
 timeout [[thread.req.timing]] specified by `rel_time` expired, otherwise
 `cv_status::no_timeout`.
-*Remarks:* If the function fails to meet the postcondition,
-`terminate()` is called [[except.terminate]].
 [*Note 5*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
-*Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
-the calling thread.
-*Throws:* Timeout-related exceptions [[thread.req.timing]].
 ``` cpp
 template<class Clock, class Duration, class Predicate>
   bool wait_until(unique_lock<mutex>& lock,
                   const chrono::time_point<Clock, Duration>& abs_time,
                   Predicate pred);
@@ -239,26 +239,26 @@ while (!pred())
   if (wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 return true;
 ```
-*Remarks:* If the function fails to meet the postcondition,
-`terminate()` is called [[except.terminate]].
-[*Note 6*: This can happen if the re-locking of the mutex throws an
-exception. — *end note*]
 *Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread.
-[*Note 7*: The returned value indicates whether the predicate evaluated
 to `true` regardless of whether the timeout was
 triggered. — *end note*]
 *Throws:* Timeout-related exceptions [[thread.req.timing]] or any
 exception thrown by `pred`.
 ``` cpp
 template<class Rep, class Period, class Predicate>
   bool wait_for(unique_lock<mutex>& lock,
                 const chrono::duration<Rep, Period>& rel_time,
                 Predicate pred);
@@ -279,21 +279,21 @@ return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred))
 ```
 [*Note 8*: There is no blocking if `pred()` is initially `true`, even
 if the timeout has already expired. — *end note*]
-*Remarks:* If the function fails to meet the postcondition,
-`terminate()` is called [[except.terminate]].
-[*Note 9*: This can happen if the re-locking of the mutex throws an
-exception. — *end note*]
 *Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread.
-[*Note 10*: The returned value indicates whether the predicate
-evaluates to `true` regardless of whether the timeout was
 triggered. — *end note*]
 *Throws:* Timeout-related exceptions [[thread.req.timing]] or any
 exception thrown by `pred`.

 ~condition_variable();
 ```
 *Preconditions:* There is no thread blocked on `*this`.
+[*Note 1*: That is, all threads have been notified; they can
 subsequently block on the lock specified in the wait. This relaxes the
 usual rules, which would have required all wait calls to happen before
 destruction. Only the notification to unblock the wait needs to happen
+before destruction. Undefined behavior ensues if a thread waits on
+`*this` once the destructor has been started, especially when the
+waiting threads are calling the wait functions in a loop or using the
+overloads of `wait`, `wait_for`, or `wait_until` that take a
 predicate. — *end note*]
 ``` cpp
 void notify_one() noexcept;
 ```
 - When unblocked, calls `lock.lock()` (possibly blocking on the lock),
   then returns.
 - The function will unblock when signaled by a call to `notify_one()` or
   a call to `notify_all()`, or spuriously.
 *Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread.
 *Throws:* Nothing.
+*Remarks:* If the function fails to meet the postcondition,
+`terminate()` is invoked [[except.terminate]].
+[*Note 2*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
 ``` cpp
 template<class Predicate>
   void wait(unique_lock<mutex>& lock, Predicate pred);
 ```
 ``` cpp
 while (!pred())
   wait(lock);
 ```
 *Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread.
 *Throws:* Any exception thrown by `pred`.
+*Remarks:* If the function fails to meet the postcondition,
+`terminate()` is invoked [[except.terminate]].
+[*Note 3*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
 ``` cpp
 template<class Clock, class Duration>
   cv_status wait_until(unique_lock<mutex>& lock,
                        const chrono::time_point<Clock, Duration>& abs_time);
 ```
   call to `notify_all()`, expiration of the absolute
   timeout [[thread.req.timing]] specified by `abs_time`, or spuriously.
 - If the function exits via an exception, `lock.lock()` is called prior
   to exiting the function.
 *Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread.
 *Returns:* `cv_status::timeout` if the absolute
 timeout [[thread.req.timing]] specified by `abs_time` expired, otherwise
 `cv_status::no_timeout`.
 *Throws:* Timeout-related exceptions [[thread.req.timing]].
+*Remarks:* If the function fails to meet the postcondition,
+`terminate()` is invoked [[except.terminate]].
+[*Note 4*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
 ``` cpp
 template<class Rep, class Period>
   cv_status wait_for(unique_lock<mutex>& lock,
                      const chrono::duration<Rep, Period>& rel_time);
 ```
 ``` cpp
 return wait_until(lock, chrono::steady_clock::now() + rel_time);
 ```
+*Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
+the calling thread.
 *Returns:* `cv_status::timeout` if the relative
 timeout [[thread.req.timing]] specified by `rel_time` expired, otherwise
 `cv_status::no_timeout`.
+*Throws:* Timeout-related exceptions [[thread.req.timing]].
+*Remarks:* If the function fails to meet the postcondition, `terminate`
+is invoked [[except.terminate]].
 [*Note 5*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
 ``` cpp
 template<class Clock, class Duration, class Predicate>
   bool wait_until(unique_lock<mutex>& lock,
                   const chrono::time_point<Clock, Duration>& abs_time,
                   Predicate pred);
   if (wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 return true;
 ```
 *Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread.
+[*Note 6*: The returned value indicates whether the predicate evaluated
 to `true` regardless of whether the timeout was
 triggered. — *end note*]
 *Throws:* Timeout-related exceptions [[thread.req.timing]] or any
 exception thrown by `pred`.
+*Remarks:* If the function fails to meet the postcondition,
+`terminate()` is invoked [[except.terminate]].
+[*Note 7*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
 ``` cpp
 template<class Rep, class Period, class Predicate>
   bool wait_for(unique_lock<mutex>& lock,
                 const chrono::duration<Rep, Period>& rel_time,
                 Predicate pred);
 ```
 [*Note 8*: There is no blocking if `pred()` is initially `true`, even
 if the timeout has already expired. — *end note*]
 *Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread.
+[*Note 9*: The returned value indicates whether the predicate evaluates
+to `true` regardless of whether the timeout was
 triggered. — *end note*]
 *Throws:* Timeout-related exceptions [[thread.req.timing]] or any
 exception thrown by `pred`.
+*Remarks:* If the function fails to meet the postcondition,
+`terminate()` is invoked [[except.terminate]].
+[*Note 10*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]

Diff to HTML by rtfpessoa