[thread.lock.unique] - C++14 → C++17

Files changed (1) hide show

tmp/tmpvscylud4/{from.md → to.md} +82 -71

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

@@ -3,13 +3,13 @@
 ``` cpp
 namespace std {
   template <class Mutex>
   class unique_lock {
   public:
- typedef Mutex mutex_type;
-    // [thread.lock.unique.cons], construct/copy/destroy:
     unique_lock() noexcept;
     explicit unique_lock(mutex_type& m);
     unique_lock(mutex_type& m, defer_lock_t) noexcept;
     unique_lock(mutex_type& m, try_to_lock_t);
     unique_lock(mutex_type& m, adopt_lock_t);
@@ -17,41 +17,43 @@ namespace std {
       unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
     template <class Rep, class Period>
       unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
     ~unique_lock();
-    unique_lock(unique_lock const&) = delete;
-    unique_lock& operator=(unique_lock const&) = delete;
     unique_lock(unique_lock&& u) noexcept;
     unique_lock& operator=(unique_lock&& u);
-    // [thread.lock.unique.locking], locking:
     void lock();
     bool try_lock();
     template <class Rep, class Period>
       bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
     template <class Clock, class Duration>
       bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
     void unlock();
-    // [thread.lock.unique.mod], modifiers:
     void swap(unique_lock& u) noexcept;
     mutex_type* release() noexcept;
-    // [thread.lock.unique.obs], observers:
     bool owns_lock() const noexcept;
     explicit operator bool () const noexcept;
     mutex_type* mutex() const noexcept;
   private:
     mutex_type* pm; // exposition only
     bool owns;      // exposition only
   };
   template <class Mutex>
     void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 }
 ```
@@ -64,15 +66,16 @@ program is undefined if the contained pointer `pm` is not null and the
 lockable object pointed to by `pm` does not exist for the entire
 remaining lifetime ([[basic.life]]) of the `unique_lock` object. The
 supplied `Mutex` type shall meet the `BasicLockable` requirements (
 [[thread.req.lockable.basic]]).
-`unique_lock<Mutex>` meets the `BasicLockable` requirements. If `Mutex`
-meets the `Lockable` requirements ([[thread.req.lockable.req]]),
-`unique_lock<Mutex>` also meets the `Lockable` requirements; if `Mutex`
-meets the `TimedLockable` requirements ([[thread.req.lockable.timed]]),
-`unique_lock<Mutex>` also meets the `TimedLockable` requirements.
 ##### `unique_lock` constructors, destructor, and assignment <a id="thread.lock.unique.cons">[[thread.lock.unique.cons]]</a>
 ``` cpp
 unique_lock() noexcept;
@@ -84,81 +87,81 @@ unique_lock() noexcept;
 ``` cpp
 explicit unique_lock(mutex_type& m);
 ```
-If `mutex_type` is not a recursive mutex the calling thread does not own
-the mutex.
 *Effects:* Constructs an object of type `unique_lock` and calls
 `m.lock()`.
-*Postconditions:* `pm == &m` and `owns == true`.
 ``` cpp
 unique_lock(mutex_type& m, defer_lock_t) noexcept;
 ```
 *Effects:* Constructs an object of type `unique_lock`.
-*Postconditions:* `pm == &m` and `owns == false`.
 ``` cpp
 unique_lock(mutex_type& m, try_to_lock_t);
 ```
-The supplied `Mutex` type shall meet the `Lockable`
 requirements ([[thread.req.lockable.req]]). If `mutex_type` is not a
 recursive mutex the calling thread does not own the mutex.
 *Effects:* Constructs an object of type `unique_lock` and calls
 `m.try_lock()`.
-*Postconditions:* `pm == &m` and `owns == res`, where `res` is the value
-returned by the call to `m.try_lock()`.
 ``` cpp
 unique_lock(mutex_type& m, adopt_lock_t);
 ```
-The calling thread own the mutex.
 *Effects:* Constructs an object of type `unique_lock`.
-*Postconditions:* `pm == &m` and `owns == true`.
 *Throws:* Nothing.
 ``` cpp
 template <class Clock, class Duration>
   unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
 ```
-If `mutex_type` is not a recursive mutex the calling thread does not own
-the mutex. The supplied `Mutex` type shall meet the `TimedLockable`
-requirements ([[thread.req.lockable.timed]]).
 *Effects:* Constructs an object of type `unique_lock` and calls
 `m.try_lock_until(abs_time)`.
-*Postconditions:* `pm == &m` and `owns == res`, where `res` is the value
-returned by the call to `m.try_lock_until(abs_time)`.
 ``` cpp
 template <class Rep, class Period>
   unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
 ```
-If `mutex_type` is not a recursive mutex the calling thread does not own
-the mutex. The supplied `Mutex` type shall meet the `TimedLockable`
-requirements ([[thread.req.lockable.timed]]).
 *Effects:* Constructs an object of type `unique_lock` and calls
 `m.try_lock_for(rel_time)`.
-*Postconditions:* `pm == &m` and `owns == res`, where `res` is the value
-returned by the call to `m.try_lock_for(rel_time)`.
 ``` cpp
 unique_lock(unique_lock&& u) noexcept;
 ```
@@ -174,13 +177,13 @@ unique_lock& operator=(unique_lock&& u);
 *Postconditions:* `pm == u_p.pm` and `owns == u_p.owns` (where `u_p` is
 the state of `u` just prior to this construction), `u.pm == 0` and
 `u.owns == false`.
-With a recursive mutex it is possible for both `*this` and `u` to own
-the same mutex before the assignment. In this case, `*this` will own the
-mutex after the assignment and `u` will not.
 *Throws:* Nothing.
 ``` cpp
 ~unique_lock();
@@ -192,96 +195,104 @@ mutex after the assignment and `u` will not.
 ``` cpp
 void lock();
 ```
-*Effects:* `pm->lock()`
-`owns == true`
-*Throws:* Any exception thrown by `pm->lock()`. `system_error` if an
-exception is required ([[thread.req.exception]]). `system_error` with
-an error condition of `operation_not_permitted` if `pm` is 0.
-`system_error` with an error condition of
-`resource_deadlock_would_occur` if on entry `owns` is `true`.
 ``` cpp
 bool try_lock();
 ```
-The supplied `Mutex` shall meet the `Lockable`
 requirements ([[thread.req.lockable.req]]).
-*Effects:* `pm->try_lock()`
 *Returns:* The value returned by the call to `try_lock()`.
-`owns == res`, where `res` is the value returned by the call to
-`try_lock()`.
-*Throws:* Any exception thrown by `pm->try_lock()`. `system_error` if an
-exception is required ([[thread.req.exception]]). `system_error` with
-an error condition of `operation_not_permitted` if `pm` is 0.
-`system_error` with an error condition of
-`resource_deadlock_would_occur` if on entry `owns` is `true`.
 ``` cpp
 template <class Clock, class Duration>
   bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 ```
 *Requires:* The supplied `Mutex` type shall meet the `TimedLockable`
 requirements ([[thread.req.lockable.timed]]).
-*Effects:* `pm->try_lock_until(abs_time)`
 *Returns:* The value returned by the call to `try_lock_until(abs_time)`.
-`owns == res`, where `res` is the value returned by the call to
-`try_lock_until(abs_time)`.
 *Throws:* Any exception thrown by `pm->try_lock_until()`. `system_error`
-if an exception is required ([[thread.req.exception]]). `system_error`
-with an error condition of `operation_not_permitted` if `pm` is 0.
-`system_error` with an error condition of
-`resource_deadlock_would_occur` if on entry `owns` is `true`.
 ``` cpp
 template <class Rep, class Period>
   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 ```
 *Requires:* The supplied `Mutex` type shall meet the `TimedLockable`
 requirements ([[thread.req.lockable.timed]]).
-*Effects:* `pm->try_lock_for(rel_time)`.
 *Returns:* The value returned by the call to `try_lock_until(rel_time)`.
-`owns == res`, where `res` is the value returned by the call to
-`try_lock_for(rel_time)`.
 *Throws:* Any exception thrown by `pm->try_lock_for()`. `system_error`
-if an exception is required ([[thread.req.exception]]). `system_error`
-with an error condition of `operation_not_permitted` if `pm` is 0.
-`system_error` with an error condition of
-`resource_deadlock_would_occur` if on entry `owns` is `true`.
 ``` cpp
 void unlock();
 ```
-*Effects:* `pm->unlock()`
-`owns == false`
 *Throws:* `system_error` when an exception is
 required ([[thread.req.exception]]).
 *Error conditions:*
-- `operation_not_permitted` — if on entry `owns` is false.
 ##### `unique_lock` modifiers <a id="thread.lock.unique.mod">[[thread.lock.unique.mod]]</a>
 ``` cpp
 void swap(unique_lock& u) noexcept;
@@ -300,27 +311,27 @@ mutex_type* release() noexcept;
 ``` cpp
 template <class Mutex>
   void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 ```
-*Effects:* `x.swap(y)`
 ##### `unique_lock` observers <a id="thread.lock.unique.obs">[[thread.lock.unique.obs]]</a>
 ``` cpp
 bool owns_lock() const noexcept;
 ```
-*Returns:* `owns`
 ``` cpp
 explicit operator bool() const noexcept;
 ```
-*Returns:* `owns`
 ``` cpp
 mutex_type *mutex() const noexcept;
 ```
-*Returns:* `pm`

 ``` cpp
 namespace std {
   template <class Mutex>
   class unique_lock {
   public:
+ using mutex_type = Mutex;
+    // [thread.lock.unique.cons], construct/copy/destroy
     unique_lock() noexcept;
     explicit unique_lock(mutex_type& m);
     unique_lock(mutex_type& m, defer_lock_t) noexcept;
     unique_lock(mutex_type& m, try_to_lock_t);
     unique_lock(mutex_type& m, adopt_lock_t);
       unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
     template <class Rep, class Period>
       unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
     ~unique_lock();
+    unique_lock(const unique_lock&) = delete;
+    unique_lock& operator=(const unique_lock&) = delete;
     unique_lock(unique_lock&& u) noexcept;
     unique_lock& operator=(unique_lock&& u);
+    // [thread.lock.unique.locking], locking
     void lock();
     bool try_lock();
     template <class Rep, class Period>
       bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
     template <class Clock, class Duration>
       bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
     void unlock();
+    // [thread.lock.unique.mod], modifiers
     void swap(unique_lock& u) noexcept;
     mutex_type* release() noexcept;
+    // [thread.lock.unique.obs], observers
     bool owns_lock() const noexcept;
     explicit operator bool () const noexcept;
     mutex_type* mutex() const noexcept;
   private:
     mutex_type* pm; // exposition only
     bool owns;      // exposition only
   };
+  template<class Mutex> unique_lock(unique_lock<Mutex>) -> unique_lock<Mutex>;
   template <class Mutex>
     void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 }
 ```
 lockable object pointed to by `pm` does not exist for the entire
 remaining lifetime ([[basic.life]]) of the `unique_lock` object. The
 supplied `Mutex` type shall meet the `BasicLockable` requirements (
 [[thread.req.lockable.basic]]).
+[*Note 1*: `unique_lock<Mutex>` meets the `BasicLockable` requirements.
+If `Mutex` meets the `Lockable` requirements (
+[[thread.req.lockable.req]]), `unique_lock<Mutex>` also meets the
+`Lockable` requirements; if `Mutex` meets the `TimedLockable`
+requirements ([[thread.req.lockable.timed]]), `unique_lock<Mutex>` also
+meets the `TimedLockable` requirements. — *end note*]
 ##### `unique_lock` constructors, destructor, and assignment <a id="thread.lock.unique.cons">[[thread.lock.unique.cons]]</a>
 ``` cpp
 unique_lock() noexcept;
 ``` cpp
 explicit unique_lock(mutex_type& m);
 ```
+*Requires:* If `mutex_type` is not a recursive mutex the calling thread
+does not own the mutex.
 *Effects:* Constructs an object of type `unique_lock` and calls
 `m.lock()`.
+*Postconditions:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
 unique_lock(mutex_type& m, defer_lock_t) noexcept;
 ```
 *Effects:* Constructs an object of type `unique_lock`.
+*Postconditions:* `pm == addressof(m)` and `owns == false`.
 ``` cpp
 unique_lock(mutex_type& m, try_to_lock_t);
 ```
+*Requires:* The supplied `Mutex` type shall meet the `Lockable`
 requirements ([[thread.req.lockable.req]]). If `mutex_type` is not a
 recursive mutex the calling thread does not own the mutex.
 *Effects:* Constructs an object of type `unique_lock` and calls
 `m.try_lock()`.
+*Postconditions:* `pm == addressof(m)` and `owns == res`, where `res` is
+the value returned by the call to `m.try_lock()`.
 ``` cpp
 unique_lock(mutex_type& m, adopt_lock_t);
 ```
+*Requires:* The calling thread owns the mutex.
 *Effects:* Constructs an object of type `unique_lock`.
+*Postconditions:* `pm == addressof(m)` and `owns == true`.
 *Throws:* Nothing.
 ``` cpp
 template <class Clock, class Duration>
   unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
 ```
+*Requires:* If `mutex_type` is not a recursive mutex the calling thread
+does not own the mutex. The supplied `Mutex` type shall meet the
+`TimedLockable` requirements ([[thread.req.lockable.timed]]).
 *Effects:* Constructs an object of type `unique_lock` and calls
 `m.try_lock_until(abs_time)`.
+*Postconditions:* `pm == addressof(m)` and `owns == res`, where `res` is
+the value returned by the call to `m.try_lock_until(abs_time)`.
 ``` cpp
 template <class Rep, class Period>
   unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
 ```
+*Requires:* If `mutex_type` is not a recursive mutex the calling thread
+does not own the mutex. The supplied `Mutex` type shall meet the
+`TimedLockable` requirements ([[thread.req.lockable.timed]]).
 *Effects:* Constructs an object of type `unique_lock` and calls
 `m.try_lock_for(rel_time)`.
+*Postconditions:* `pm == addressof(m)` and `owns == res`, where `res` is
+the value returned by the call to `m.try_lock_for(rel_time)`.
 ``` cpp
 unique_lock(unique_lock&& u) noexcept;
 ```
 *Postconditions:* `pm == u_p.pm` and `owns == u_p.owns` (where `u_p` is
 the state of `u` just prior to this construction), `u.pm == 0` and
 `u.owns == false`.
+[*Note 1*: With a recursive mutex it is possible for both `*this` and
+`u` to own the same mutex before the assignment. In this case, `*this`
+will own the mutex after the assignment and `u` will not. — *end note*]
 *Throws:* Nothing.
 ``` cpp
 ~unique_lock();
 ``` cpp
 void lock();
 ```
+*Effects:* As if by `pm->lock()`.
+*Postconditions:* `owns == true`.
+*Throws:* Any exception thrown by `pm->lock()`. `system_error` when an
+exception is required ([[thread.req.exception]]).
+*Error conditions:*
+- `operation_not_permitted` — if `pm` is `nullptr`.
+- `resource_deadlock_would_occur` — if on entry `owns` is `true`.
 ``` cpp
 bool try_lock();
 ```
+*Requires:* The supplied `Mutex` shall meet the `Lockable`
 requirements ([[thread.req.lockable.req]]).
+*Effects:* As if by `pm->try_lock()`.
 *Returns:* The value returned by the call to `try_lock()`.
+*Postconditions:* `owns == res`, where `res` is the value returned by
+the call to `try_lock()`.
+*Throws:* Any exception thrown by `pm->try_lock()`. `system_error` when
+an exception is required ([[thread.req.exception]]).
+*Error conditions:*
+- `operation_not_permitted` — if `pm` is `nullptr`.
+- `resource_deadlock_would_occur` — if on entry `owns` is `true`.
 ``` cpp
 template <class Clock, class Duration>
   bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 ```
 *Requires:* The supplied `Mutex` type shall meet the `TimedLockable`
 requirements ([[thread.req.lockable.timed]]).
+*Effects:* As if by `pm->try_lock_until(abs_time)`.
 *Returns:* The value returned by the call to `try_lock_until(abs_time)`.
+*Postconditions:* `owns == res`, where `res` is the value returned by
+the call to `try_lock_until(abs_time)`.
 *Throws:* Any exception thrown by `pm->try_lock_until()`. `system_error`
+when an exception is required ([[thread.req.exception]]).
+*Error conditions:*
+- `operation_not_permitted` — if `pm` is `nullptr`.
+- `resource_deadlock_would_occur` — if on entry `owns` is `true`.
 ``` cpp
 template <class Rep, class Period>
   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 ```
 *Requires:* The supplied `Mutex` type shall meet the `TimedLockable`
 requirements ([[thread.req.lockable.timed]]).
+*Effects:* As if by `pm->try_lock_for(rel_time)`.
 *Returns:* The value returned by the call to `try_lock_until(rel_time)`.
+*Postconditions:* `owns == res`, where `res` is the value returned by
+the call to `try_lock_for(rel_time)`.
 *Throws:* Any exception thrown by `pm->try_lock_for()`. `system_error`
+when an exception is required ([[thread.req.exception]]).
+*Error conditions:*
+- `operation_not_permitted` — if `pm` is `nullptr`.
+- `resource_deadlock_would_occur` — if on entry `owns` is `true`.
 ``` cpp
 void unlock();
 ```
+*Effects:* As if by `pm->unlock()`.
+*Postconditions:* `owns == false`.
 *Throws:* `system_error` when an exception is
 required ([[thread.req.exception]]).
 *Error conditions:*
+- `operation_not_permitted` — if on entry `owns` is `false`.
 ##### `unique_lock` modifiers <a id="thread.lock.unique.mod">[[thread.lock.unique.mod]]</a>
 ``` cpp
 void swap(unique_lock& u) noexcept;
 ``` cpp
 template <class Mutex>
   void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 ```
+*Effects:* As if by `x.swap(y)`.
 ##### `unique_lock` observers <a id="thread.lock.unique.obs">[[thread.lock.unique.obs]]</a>
 ``` cpp
 bool owns_lock() const noexcept;
 ```
+*Returns:* `owns`.
 ``` cpp
 explicit operator bool() const noexcept;
 ```
+*Returns:* `owns`.
 ``` cpp
 mutex_type *mutex() const noexcept;
 ```
+*Returns:* `pm`.

Diff to HTML by rtfpessoa