[thread.condition.condvarany]

Files changed (1) hide show

tmp/tmp0etoieay/{from.md → to.md} +39 -28

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

@@ -1,14 +1,16 @@
 ### Class `condition_variable_any` <a id="thread.condition.condvarany">[[thread.condition.condvarany]]</a>
 A `Lock` type shall meet the `BasicLockable` requirements (
-[[thread.req.lockable.basic]]). All of the standard mutex types meet
-this requirement. If a `Lock` type other than one of the standard mutex
-types or a `unique_lock` wrapper for a standard mutex type is used with
 `condition_variable_any`, the user must ensure that any necessary
 synchronization is in place with respect to the predicate associated
-with the `condition_variable_any` instance.
 ``` cpp
 namespace std {
   class condition_variable_any {
   public:
@@ -57,19 +59,21 @@ required ([[thread.req.exception]]).
 ``` cpp
 ~condition_variable_any();
 ```
-There shall be no thread blocked on `*this`. That is, all threads shall
-have been notified; they may 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 must happen before destruction. The user must 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.
 *Effects:* Destroys the object.
 ``` cpp
 void notify_one() noexcept;
@@ -87,27 +91,29 @@ void notify_all() noexcept;
 ``` cpp
 template <class Lock>
   void wait(Lock& lock);
 ```
-*Note:* if any of the `wait` functions exits via an exception, it is
 unspecified whether the `Lock` is held. One can use a `Lock` type that
-allows to query that, such as the `unique_lock` wrapper.
 *Effects:*
 - Atomically calls `lock.unlock()` and blocks on `*this`.
 - When unblocked, calls `lock.lock()` (possibly blocking on the lock)
   and returns.
 - The function will unblock when signaled by a call to `notify_one()`, a
   call to `notify_all()`, or spuriously.
 *Remarks:* If the function fails to meet the postcondition,
-`std::terminate()` shall be called ([[except.terminate]]). This can
-happen if the re-locking of the mutex throws an exception.
-`lock` is locked by the calling thread.
 *Throws:* Nothing.
 ``` cpp
 template <class Lock, class Predicate>
@@ -137,14 +143,16 @@ template <class Lock, class Clock, class Duration>
   spuriously.
 - If the function exits via an exception, `lock.lock()` shall be called
   prior to exiting the function.
 *Remarks:* If the function fails to meet the postcondition,
-`std::terminate()` shall be called ([[except.terminate]]). This can
-happen if the re-locking of the mutex throws an exception.
-`lock` 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`.
@@ -164,14 +172,16 @@ 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,
-`std::terminate()` shall be called ([[except.terminate]]). This can
-happen if the re-locking of the mutex throws an exception.
-`lock` is locked by the calling thread.
 *Throws:* Timeout-related exceptions ([[thread.req.timing]]).
 ``` cpp
 template <class Lock, class Clock, class Duration, class Predicate>
@@ -185,15 +195,16 @@ while (!pred())
   if (wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 return true;
 ```
-There is no blocking if `pred()` is initially `true`, or if the timeout
-has already expired.
-The returned value indicates whether the predicate evaluates to `true`
-regardless of whether the timeout was triggered.
 ``` cpp
 template <class Lock, class Rep, class Period, class Predicate>
   bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);
 ```

 ### Class `condition_variable_any` <a id="thread.condition.condvarany">[[thread.condition.condvarany]]</a>
 A `Lock` type shall meet the `BasicLockable` requirements (
+[[thread.req.lockable.basic]]).
+[*Note 1*: All of the standard mutex types meet this requirement. If a
+`Lock` type other than one of the standard mutex types or a
+`unique_lock` wrapper for a standard mutex type is used with
 `condition_variable_any`, the user must ensure that any necessary
 synchronization is in place with respect to the predicate associated
+with the `condition_variable_any` instance. — *end note*]
 ``` cpp
 namespace std {
   class condition_variable_any {
   public:
 ``` cpp
 ~condition_variable_any();
 ```
+*Requires:* There shall be no thread blocked on `*this`.
+[*Note 1*: That is, all threads shall have been notified; they may
+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 must happen
+before destruction. The user must 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*]
 *Effects:* Destroys the object.
 ``` cpp
 void notify_one() noexcept;
 ``` cpp
 template <class Lock>
   void wait(Lock& lock);
 ```
+[*Note 2*: If any of the `wait` functions exits via an exception, it is
 unspecified whether the `Lock` is held. One can use a `Lock` type that
+allows to query that, such as the `unique_lock` wrapper. — *end note*]
 *Effects:*
 - Atomically calls `lock.unlock()` and blocks on `*this`.
 - When unblocked, calls `lock.lock()` (possibly blocking on the lock)
   and returns.
 - The function will unblock when signaled by a call to `notify_one()`, a
   call to `notify_all()`, or spuriously.
 *Remarks:* If the function fails to meet the postcondition,
+`terminate()` shall be called ([[except.terminate]]).
+[*Note 3*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
+*Postconditions:* `lock` is locked by the calling thread.
 *Throws:* Nothing.
 ``` cpp
 template <class Lock, class Predicate>
   spuriously.
 - If the function exits via an exception, `lock.lock()` shall be called
   prior to exiting the function.
 *Remarks:* If the function fails to meet the postcondition,
+`terminate()` shall be called ([[except.terminate]]).
+[*Note 4*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
+*Postconditions:* `lock` 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`.
 *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()` shall be called ([[except.terminate]]).
+[*Note 5*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
+*Postconditions:* `lock` is locked by the calling thread.
 *Throws:* Timeout-related exceptions ([[thread.req.timing]]).
 ``` cpp
 template <class Lock, class Clock, class Duration, class Predicate>
   if (wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 return true;
 ```
+[*Note 6*: There is no blocking if `pred()` is initially `true`, or if
+the timeout has already expired. — *end note*]
+[*Note 7*: The returned value indicates whether the predicate evaluates
+to `true` regardless of whether the timeout was
+triggered. — *end note*]
 ``` cpp
 template <class Lock, class Rep, class Period, class Predicate>
   bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);
 ```

Diff to HTML by rtfpessoa