[thread.lock] - C++11 → C++14

Files changed (1) hide show

tmp/tmpnh_d056w/{from.md → to.md} +313 -2

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

@@ -107,11 +107,11 @@ namespace std {
     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) noexcept;
     // [thread.lock.unique.locking], locking:
     void lock();
     bool try_lock();
@@ -251,11 +251,11 @@ 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) noexcept;
 ```
 *Effects:* If `owns` calls `pm->unlock()`.
 *Postconditions:* `pm == u_p.pm` and `owns == u_p.owns` (where `u_p` is
@@ -264,10 +264,12 @@ the state of `u` just prior to this construction), `u.pm == 0` and
 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.
 ``` cpp
 ~unique_lock();
 ```
 *Effects:* If `owns` calls `pm->unlock()`.
@@ -406,5 +408,314 @@ explicit operator bool() const noexcept;
 mutex_type *mutex() const noexcept;
 ```
 *Returns:* `pm`

     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();
 *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
 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();
 ```
 *Effects:* If `owns` calls `pm->unlock()`.
 mutex_type *mutex() const noexcept;
 ```
 *Returns:* `pm`
+#### Class template `shared_lock` <a id="thread.lock.shared">[[thread.lock.shared]]</a>
+``` cpp
+namespace std {
+template <class Mutex>
+class shared_lock {
+public:
+  typedef Mutex mutex_type;
+  // Shared locking
+  shared_lock() noexcept;
+  explicit shared_lock(mutex_type& m);  // blocking
+  shared_lock(mutex_type& m, defer_lock_t) noexcept;
+  shared_lock(mutex_type& m, try_to_lock_t);
+  shared_lock(mutex_type& m, adopt_lock_t);
+  template <class Clock, class Duration>
+    shared_lock(mutex_type& m,
+                const chrono::time_point<Clock, Duration>& abs_time);
+  template <class Rep, class Period>
+    shared_lock(mutex_type& m,
+                const chrono::duration<Rep, Period>& rel_time);
+  ~shared_lock();
+  shared_lock(shared_lock const&) = delete;
+  shared_lock& operator=(shared_lock const&) = delete;
+  shared_lock(shared_lock&& u) noexcept;
+  shared_lock& operator=(shared_lock&& u) noexcept;
+  void lock();  // blocking
+  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();
+  // Setters
+  void swap(shared_lock& u) noexcept;
+  mutex_type* release() noexcept;
+  // Getters
+  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(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
+}  // std
+```
+An object of type `shared_lock` controls the shared ownership of a
+lockable object within a scope. Shared ownership of the lockable object
+may be acquired at construction or after construction, and may be
+transferred, after acquisition, to another `shared_lock` object. Objects
+of type `shared_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 `shared_lock` object. The
+supplied `Mutex` type shall meet the shared mutex requirements (
+[[thread.sharedtimedmutex.requirements]]).
+`shared_lock<Mutex>` meets the `TimedLockable` requirements (
+[[thread.req.lockable.timed]]).
+##### `shared_lock` constructors, destructor, and assignment <a id="thread.lock.shared.cons">[[thread.lock.shared.cons]]</a>
+``` cpp
+shared_lock() noexcept;
+```
+*Effects:* Constructs an object of type `shared_lock`.
+*Postconditions:* `pm == nullptr` and `owns == false`.
+``` cpp
+explicit shared_lock(mutex_type& m);
+```
+*Requires:* The calling thread does not own the mutex for any ownership
+mode.
+*Effects:* Constructs an object of type `shared_lock` and calls
+`m.lock_shared()`.
+*Postconditions:* `pm == &m` and `owns == true`.
+``` cpp
+shared_lock(mutex_type& m, defer_lock_t) noexcept;
+```
+*Effects:* Constructs an object of type `shared_lock`.
+*Postconditions:* `pm == &m` and `owns == false`.
+``` cpp
+shared_lock(mutex_type& m, try_to_lock_t);
+```
+*Requires:* The calling thread does not own the mutex for any ownership
+mode.
+*Effects:* Constructs an object of type `shared_lock` and calls
+`m.try_lock_shared()`.
+*Postconditions:* `pm == &m` and `owns == res` where `res` is the value
+returned by the call to `m.try_lock_shared()`.
+``` cpp
+shared_lock(mutex_type& m, adopt_lock_t);
+```
+*Requires:* The calling thread has shared ownership of the mutex.
+*Effects:* Constructs an object of type `shared_lock`.
+*Postconditions:* `pm == &m` and `owns == true`.
+``` cpp
+template <class Clock, class Duration>
+  shared_lock(mutex_type& m,
+              const chrono::time_point<Clock, Duration>& abs_time);
+```
+*Requires:* The calling thread does not own the mutex for any ownership
+mode.
+*Effects:* Constructs an object of type `shared_lock` and calls
+`m.try_lock_shared_until(abs_time)`.
+*Postconditions:* `pm == &m` and `owns == res` where `res` is the value
+returned by the call to `m.try_lock_shared_until(abs_time)`.
+``` cpp
+template <class Rep, class Period>
+  shared_lock(mutex_type& m,
+              const chrono::duration<Rep, Period>& rel_time);
+```
+*Requires:* The calling thread does not own the mutex for any ownership
+mode.
+*Effects:* Constructs an object of type `shared_lock` and calls
+`m.try_lock_shared_for(rel_time)`.
+*Postconditions:* `pm == &m` and `owns == res` where `res` is the value
+returned by the call to `m.try_lock_shared_for(rel_time)`.
+``` cpp
+~shared_lock();
+```
+*Effects:* If `owns` calls `pm->unlock_shared()`.
+``` cpp
+shared_lock(shared_lock&& sl) noexcept;
+```
+*Postconditions:* `pm == &sl_p.pm` and `owns == sl_p.owns` (where `sl_p`
+is the state of `sl` just prior to this construction),
+`sl.pm == nullptr` and `sl.owns == false`.
+``` cpp
+shared_lock& operator=(shared_lock&& sl) noexcept;
+```
+*Effects:* If `owns` calls `pm->unlock_shared()`.
+*Postconditions:* `pm == &sl_p.pm` and `owns == sl_p.owns` (where `sl_p`
+is the state of `sl` just prior to this assignment), `sl.pm == nullptr`
+and `sl.owns == false`.
+##### `shared_lock` locking <a id="thread.lock.shared.locking">[[thread.lock.shared.locking]]</a>
+``` cpp
+void lock();
+```
+*Effects:* `pm->lock_shared()`.
+*Postconditions:* `owns == true`.
+*Throws:* Any exception thrown by `pm->lock_shared()`. `system_error` if
+an exception is required ([[thread.req.exception]]). `system_error`
+with an error condition of `operation_not_permitted` if `pm` is
+`nullptr`. `system_error` with an error condition of
+`resource_deadlock_would_occur` if on entry `owns` is `true`.
+``` cpp
+bool try_lock();
+```
+*Effects:* `pm->try_lock_shared()`.
+*Returns:* The value returned by the call to `pm->try_lock_shared()`.
+*Postconditions:* `owns == res`, where `res` is the value returned by
+the call to `pm->try_lock_shared()`.
+*Throws:* Any exception thrown by `pm->try_lock_shared()`.
+`system_error` if an exception is required ([[thread.req.exception]]).
+`system_error` with an error condition of `operation_not_permitted` if
+`pm` is `nullptr`. `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);
+```
+*Effects:* `pm->try_lock_shared_until(abs_time)`.
+*Returns:* The value returned by the call to
+`pm->try_lock_shared_until(abs_time)`.
+*Postconditions:* `owns == res`, where `res` is the value returned by
+the call to `pm->try_lock_shared_until(abs_time)`.
+*Throws:* Any exception thrown by `pm->try_lock_shared_until(abs_time)`.
+`system_error` if an exception is required ([[thread.req.exception]]).
+`system_error` with an error condition of `operation_not_permitted` if
+`pm` is `nullptr`. `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);
+```
+*Effects:* `pm->try_lock_shared_for(rel_time)`.
+*Returns:* The value returned by the call to
+`pm->try_lock_shared_for(rel_time)`.
+*Postconditions:* `owns == res`, where `res` is the value returned by
+the call to `pm->try_lock_shared_for(rel_time)`.
+*Throws:* Any exception thrown by `pm->try_lock_shared_for(rel_time)`.
+`system_error` if an exception is required  ([[thread.req.exception]]).
+`system_error` with an error condition of `operation_not_permitted` if
+`pm` is `nullptr`. `system_error` with an error condition of
+`resource_deadlock_would_occur` if on entry `owns` is `true`.
+``` cpp
+void unlock();
+```
+*Effects:* `pm->unlock_shared()`.
+*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`.
+##### `shared_lock` modifiers <a id="thread.lock.shared.mod">[[thread.lock.shared.mod]]</a>
+``` cpp
+void swap(shared_lock& sl) noexcept;
+```
+*Effects:* Swaps the data members of `*this` and `sl`.
+``` cpp
+mutex_type* release() noexcept;
+```
+*Returns:* The previous value of `pm`.
+*Postconditions:* `pm == nullptr` and `owns == false`.
+``` cpp
+template <class Mutex>
+  void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
+```
+*Effects:* `x.swap(y)`.
+##### `shared_lock` observers <a id="thread.lock.shared.obs">[[thread.lock.shared.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