[thread.condition.condvar] - C++11 → C++14

Files changed (1) hide show

tmp/tmpnggb_2ml/{from.md → to.md} +43 -52

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

@@ -91,32 +91,29 @@ void wait(unique_lock<mutex>& lock);
 `lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
 thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
-  supplied by all concurrently waiting (via `wait` or `timed_wait`)
-  threads.
 *Effects:*
 - Atomically calls `lock.unlock()` and blocks on `*this`.
 - 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.
-- If the function exits via an exception, `lock.lock()` shall be called
-  prior to exiting the function scope.
 `lock.owns_lock()` is `true` and `lock.mutex()` 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 Predicate>
   void wait(unique_lock<mutex>& lock, Predicate pred);
 ```
@@ -124,29 +121,29 @@ template <class Predicate>
 *Requires:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
-  supplied by all concurrently waiting (via `wait` or `timed_wait`)
-  threads.
-*Effects:*
 ``` cpp
 while (!pred())
   wait(lock);
 ```
 `lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
 thread.
-*Throws:* `std::system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` cpp
 template <class Clock, class Duration>
   cv_status wait_until(unique_lock<mutex>& lock,
                        const chrono::time_point<Clock, Duration>& abs_time);
@@ -168,25 +165,24 @@ thread, and either
 - 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.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:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` cpp
 template <class Rep, class Period>
   cv_status wait_for(unique_lock<mutex>& lock,
                      const chrono::duration<Rep, Period>& rel_time);
@@ -198,29 +194,28 @@ thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
-*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.owns_lock()` is `true` and `lock.mutex()` 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 Clock, class Duration, class Predicate>
   bool wait_until(unique_lock<mutex>& lock,
                   const chrono::time_point<Clock, Duration>& abs_time,
@@ -230,36 +225,34 @@ template <class Clock, class Duration, class Predicate>
 *Requires:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
-  supplied by all concurrently waiting (via `wait` or `timed_wait`)
-  threads.
-*Effects:*
 ``` cpp
 while (!pred())
   if (wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 return true;
 ```
-*Returns:* `pred()`
 `lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
 thread.
 The returned value indicates whether the predicate evaluated to `true`
 regardless of whether the timeout was triggered.
-*Throws:* `std::system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` cpp
 template <class Rep, class Period, class Predicate>
   bool wait_for(unique_lock<mutex>& lock,
                 const chrono::duration<Rep, Period>& rel_time,
@@ -272,29 +265,27 @@ thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
-*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.owns_lock()` is `true` and `lock.mutex()` 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()`.

 `lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
 thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
+  supplied by all concurrently waiting (via `wait`, `wait_for`, or
+ `wait_until`) threads.
 *Effects:*
 - Atomically calls `lock.unlock()` and blocks on `*this`.
 - 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,
+`std::terminate()` shall be called ([[except.terminate]]). This can
+happen if the re-locking of the mutex throws an exception.
 `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);
 ```
 *Requires:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
+  supplied by all concurrently waiting (via `wait`, `wait_for`, or
+ `wait_until`) threads.
+*Effects:* Equivalent to:
 ``` cpp
 while (!pred())
   wait(lock);
 ```
+*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.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
 thread.
+*Throws:* Timeout-related exceptions ([[thread.req.timing]]) or 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);
 - 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.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);
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
+*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.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,
 *Requires:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
 the calling thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
+  supplied by all concurrently waiting (via `wait`, `wait_for`, or
+ `wait_until`) threads.
+*Effects:* Equivalent to:
 ``` cpp
 while (!pred())
   if (wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 return true;
 ```
+*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.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
 thread.
 The returned value indicates whether the predicate evaluated to `true`
 regardless of whether the timeout was triggered.
+*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,
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
+*Effects:* Equivalent to:
 ``` 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.
+*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.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
 thread.
 The returned value indicates whether the predicate evaluates to `true`
 regardless of whether the timeout was triggered.
+*Throws:* Timeout-related exceptions ([[thread.req.timing]]) or any
+exception thrown by `pred`.

Diff to HTML by rtfpessoa