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

Files changed (1) hide show

tmp/tmpp_mbt8e5/{from.md → to.md} +63 -75

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

@@ -48,12 +48,10 @@ namespace std {
   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;
 }
 ```
@@ -62,123 +60,113 @@ object within a scope. Ownership of the lockable object may be acquired
 at construction or after construction, and may be transferred, after
 acquisition, to another `unique_lock` object. Objects of type
 `unique_lock` are not copyable but are movable. The behavior of a
 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]]).
-[*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;
 ```
-*Effects:* Constructs an object of type `unique_lock`.
-*Postconditions:* `pm == 0` and `owns == false`.
 ``` 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`.
 ``` cpp
 unique_lock& operator=(unique_lock&& u);
 ```
 *Effects:* If `owns` calls `pm->unlock()`.
-*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*]
@@ -189,44 +177,44 @@ will own the mutex after the assignment and `u` will not. — *end note*]
 ~unique_lock();
 ```
 *Effects:* If `owns` calls `pm->unlock()`.
-##### `unique_lock` locking <a id="thread.lock.unique.locking">[[thread.lock.unique.locking]]</a>
 ``` 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`.
@@ -234,22 +222,22 @@ an exception is required ([[thread.req.exception]]).
 ``` 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`.
@@ -257,22 +245,22 @@ when an exception is required ([[thread.req.exception]]).
 ``` 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`.
@@ -281,20 +269,20 @@ when an exception is required ([[thread.req.exception]]).
 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;
 ```
@@ -304,20 +292,20 @@ void swap(unique_lock& u) noexcept;
 mutex_type* release() noexcept;
 ```
 *Returns:* The previous value of `pm`.
-*Postconditions:* `pm == 0` and `owns == false`.
 ``` 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;
 ```

   private:
     mutex_type* pm;             // exposition only
     bool owns;                  // exposition only
   };
   template<class Mutex>
     void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 }
 ```
 at construction or after construction, and may be transferred, after
 acquisition, to another `unique_lock` object. Objects of type
 `unique_lock` are not copyable but are movable. The behavior of a
 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 *Cpp17BasicLockable* requirements
+[[thread.req.lockable.basic]].
+[*Note 1*: `unique_lock<Mutex>` meets the *Cpp17BasicLockable*
+requirements. If `Mutex` meets the *Cpp17Lockable* requirements
+[[thread.req.lockable.req]], `unique_lock<Mutex>` also meets the
+*Cpp17Lockable* requirements; if `Mutex` meets the *Cpp17TimedLockable*
+requirements [[thread.req.lockable.timed]], `unique_lock<Mutex>` also
+meets the *Cpp17TimedLockable* requirements. — *end note*]
+##### Constructors, destructor, and assignment <a id="thread.lock.unique.cons">[[thread.lock.unique.cons]]</a>
 ``` cpp
 unique_lock() noexcept;
 ```
+*Ensures:* `pm == 0` and `owns == false`.
 ``` cpp
 explicit unique_lock(mutex_type& m);
 ```
+*Preconditions:* If `mutex_type` is not a recursive mutex the calling
+thread does not own the mutex.
+*Effects:* Calls `m.lock()`.
+*Ensures:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
 unique_lock(mutex_type& m, defer_lock_t) noexcept;
 ```
+*Ensures:* `pm == addressof(m)` and `owns == false`.
 ``` cpp
 unique_lock(mutex_type& m, try_to_lock_t);
 ```
+*Preconditions:* The supplied `Mutex` type meets the *Cpp17Lockable*
+requirements [[thread.req.lockable.req]]. If `mutex_type` is not a
 recursive mutex the calling thread does not own the mutex.
+*Effects:* Calls `m.try_lock()`.
+*Ensures:* `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);
 ```
+*Preconditions:* The calling thread owns the mutex.
+*Ensures:* `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);
 ```
+*Preconditions:* If `mutex_type` is not a recursive mutex the calling
+thread does not own the mutex. The supplied `Mutex` type meets the
+*Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
+*Effects:* Calls `m.try_lock_until(abs_time)`.
+*Ensures:* `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);
 ```
+*Preconditions:* If `mutex_type` is not a recursive mutex the calling
+thread does not own the mutex. The supplied `Mutex` type meets the
+*Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
+*Effects:* Calls `m.try_lock_for(rel_time)`.
+*Ensures:* `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;
 ```
+*Ensures:* `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`.
 ``` cpp
 unique_lock& operator=(unique_lock&& u);
 ```
 *Effects:* If `owns` calls `pm->unlock()`.
+*Ensures:* `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*]
 ~unique_lock();
 ```
 *Effects:* If `owns` calls `pm->unlock()`.
+##### Locking <a id="thread.lock.unique.locking">[[thread.lock.unique.locking]]</a>
 ``` cpp
 void lock();
 ```
 *Effects:* As if by `pm->lock()`.
+*Ensures:* `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();
 ```
+*Preconditions:* The supplied `Mutex` meets the *Cpp17Lockable*
+requirements [[thread.req.lockable.req]].
 *Effects:* As if by `pm->try_lock()`.
 *Returns:* The value returned by the call to `try_lock()`.
+*Ensures:* `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);
 ```
+*Preconditions:* The supplied `Mutex` type meets the
+*Cpp17TimedLockable* 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)`.
+*Ensures:* `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);
 ```
+*Preconditions:* The supplied `Mutex` type meets the
+*Cpp17TimedLockable* 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_for(rel_time)`.
+*Ensures:* `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`.
 void unlock();
 ```
 *Effects:* As if by `pm->unlock()`.
+*Ensures:* `owns == false`.
 *Throws:* `system_error` when an exception is
+required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if on entry `owns` is `false`.
+##### Modifiers <a id="thread.lock.unique.mod">[[thread.lock.unique.mod]]</a>
 ``` cpp
 void swap(unique_lock& u) noexcept;
 ```
 mutex_type* release() noexcept;
 ```
 *Returns:* The previous value of `pm`.
+*Ensures:* `pm == 0` and `owns == false`.
 ``` cpp
 template<class Mutex>
   void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 ```
 *Effects:* As if by `x.swap(y)`.
+##### Observers <a id="thread.lock.unique.obs">[[thread.lock.unique.obs]]</a>
 ``` cpp
 bool owns_lock() const noexcept;
 ```

Diff to HTML by rtfpessoa