[thread.condition.condvarany]

Files changed (1) hide show

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

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

@@ -48,12 +48,12 @@ condition_variable_any();
 *Throws:* `bad_alloc` or `system_error` when an exception is
 required ([[thread.req.exception]]).
 *Error conditions:*
-- `resource_unavailable_try_again` — if any native handle type
- manipulated is not available.
 - `operation_not_permitted` — if the thread does not have the privilege
   to perform the operation.
 ``` cpp
 ~condition_variable_any();
@@ -98,28 +98,25 @@ allows to query that, such as the `unique_lock` wrapper.
 - 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.
-- If the function exits via an exception, `lock.lock()` shall be called
-  prior to exiting the function scope.
 `lock` is locked by the calling thread.
-*Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` cpp
 template <class Lock, class Predicate>
   void wait(Lock& lock, Predicate pred);
 ```
-*Effects:*
 ``` cpp
 while (!pred())
   wait(lock);
 ```
@@ -137,91 +134,73 @@ template <class Lock, class Clock, class Duration>
 - The function will unblock when signaled by a call to `notify_one()`, a
   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()` shall be called
-  prior to exiting the function scope.
 `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`.
-*Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` cpp
 template <class Lock, class Rep, class Period>
   cv_status wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
 ```
-*Effects:* as if
 ``` 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`.
 `lock` is locked by the calling thread.
-*Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` cpp
 template <class Lock, class Clock, class Duration, class Predicate>
   bool wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& abs_time, Predicate pred);
 ```
-*Effects:*
 ``` cpp
 while (!pred())
   if (wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 return true;
 ```
-*Returns:* `pred()`
 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);
 ```
-*Effects:* as if
 ``` cpp
 return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred));
 ```
-There is no blocking if `pred()` is initially `true`, even if the
-timeout has already expired.
-`lock` is locked by the calling thread.
-*Returns:* `pred()`
-The returned value indicates whether the predicate evaluates to `true`
-regardless of whether the timeout was triggered.
-*Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.

 *Throws:* `bad_alloc` or `system_error` when an exception is
 required ([[thread.req.exception]]).
 *Error conditions:*
+- `resource_unavailable_try_again` — if some non-memory resource
+ limitation prevents initialization.
 - `operation_not_permitted` — if the thread does not have the privilege
   to perform the operation.
 ``` cpp
 ~condition_variable_any();
 - 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>
   void wait(Lock& lock, Predicate pred);
 ```
+*Effects:* Equivalent to:
 ``` cpp
 while (!pred())
   wait(lock);
 ```
 - The function will unblock when signaled by a call to `notify_one()`, a
   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()` 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`.
+*Throws:* Timeout-related exceptions ([[thread.req.timing]]).
 ``` cpp
 template <class Lock, class Rep, class Period>
   cv_status wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
 ```
+*Effects:* Equivalent to:
 ``` 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,
+`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>
   bool wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& abs_time, Predicate pred);
 ```
+*Effects:* Equivalent to:
 ``` cpp
 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);
 ```
+*Effects:* Equivalent to:
 ``` cpp
 return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred));
 ```

Diff to HTML by rtfpessoa