[thread.req.lockable] - C++17 → C++20

Files changed (1) hide show

tmp/tmp4f7jvm6p/{from.md → to.md} +37 -37

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

@@ -1,38 +1,38 @@
-### Requirements for `Lockable` types <a id="thread.req.lockable">[[thread.req.lockable]]</a>
 #### In general <a id="thread.req.lockable.general">[[thread.req.lockable.general]]</a>
 An *execution agent* is an entity such as a thread that may perform work
 in parallel with other execution agents.
-[*Note 1*: Implementations or users may introduce other kinds of agents
 such as processes or thread-pool tasks. — *end note*]
-The calling agent is determined by context, e.g. the calling thread that
-contains the call, and so on.
 [*Note 2*: Some lockable objects are “agent oblivious” in that they
 work for any execution agent model because they do not determine or
 store the agent’s ID (e.g., an ordinary spin lock). — *end note*]
-The standard library templates `unique_lock` ([[thread.lock.unique]]),
-`shared_lock` ([[thread.lock.shared]]), `scoped_lock` (
-[[thread.lock.scoped]]), `lock_guard` ([[thread.lock.guard]]), `lock`,
-`try_lock` ([[thread.lock.algorithm]]), and `condition_variable_any` (
-[[thread.condition.condvarany]]) all operate on user-supplied lockable
-objects. The `BasicLockable` requirements, the `Lockable` requirements,
-and the `TimedLockable` requirements list the requirements imposed by
-these library types in order to acquire or release ownership of a `lock`
-by a given execution agent.
 [*Note 3*: The nature of any lock ownership and any synchronization it
-may entail are not part of these requirements. — *end note*]
-#### `BasicLockable` requirements <a id="thread.req.lockable.basic">[[thread.req.lockable.basic]]</a>
-A type `L` meets the `BasicLockable` requirements if the following
 expressions are well-formed and have the specified semantics (`m`
 denotes a value of type `L`).
 ``` cpp
 m.lock()
@@ -44,20 +44,20 @@ acquired for the current execution agent.
 ``` cpp
 m.unlock()
 ```
-*Requires:* The current execution agent shall hold a lock on `m`.
 *Effects:* Releases a lock on `m` held by the current execution agent.
 *Throws:* Nothing.
-#### `Lockable` requirements <a id="thread.req.lockable.req">[[thread.req.lockable.req]]</a>
-A type `L` meets the `Lockable` requirements if it meets the
-`BasicLockable` requirements and the following expressions are
 well-formed and have the specified semantics (`m` denotes a value of
 type `L`).
 ``` cpp
 m.try_lock()
@@ -69,44 +69,44 @@ been acquired for the current execution agent.
 *Return type:* `bool`.
 *Returns:* `true` if the lock was acquired, `false` otherwise.
-#### `TimedLockable` requirements <a id="thread.req.lockable.timed">[[thread.req.lockable.timed]]</a>
-A type `L` meets the `TimedLockable` requirements if it meets the
-`Lockable` requirements and the following expressions are well-formed
-and have the specified semantics (`m` denotes a value of type `L`,
-`rel_time` denotes a value of an instantiation of `duration` (
-[[time.duration]]), and `abs_time` denotes a value of an instantiation
-of `time_point` ([[time.point]])).
 ``` cpp
 m.try_lock_for(rel_time)
 ```
 *Effects:* Attempts to acquire a lock for the current execution agent
-within the relative timeout ([[thread.req.timing]]) specified by
-`rel_time`. The function shall not return within the timeout specified
-by `rel_time` unless it has obtained a lock on `m` for the current
-execution agent. If an exception is thrown then a lock shall not have
-been acquired for the current execution agent.
 *Return type:* `bool`.
 *Returns:* `true` if the lock was acquired, `false` otherwise.
 ``` cpp
 m.try_lock_until(abs_time)
 ```
 *Effects:* Attempts to acquire a lock for the current execution agent
-before the absolute timeout ([[thread.req.timing]]) specified by
-`abs_time`. The function shall not return before the timeout specified
-by `abs_time` unless it has obtained a lock on `m` for the current
-execution agent. If an exception is thrown then a lock shall not have
-been acquired for the current execution agent.
 *Return type:* `bool`.
 *Returns:* `true` if the lock was acquired, `false` otherwise.

+### Requirements for *Cpp17Lockable* types <a id="thread.req.lockable">[[thread.req.lockable]]</a>
 #### In general <a id="thread.req.lockable.general">[[thread.req.lockable.general]]</a>
 An *execution agent* is an entity such as a thread that may perform work
 in parallel with other execution agents.
+[*Note 1*: Implementations or users can introduce other kinds of agents
 such as processes or thread-pool tasks. — *end note*]
+The calling agent is determined by context, e.g., the calling thread
+that contains the call, and so on.
 [*Note 2*: Some lockable objects are “agent oblivious” in that they
 work for any execution agent model because they do not determine or
 store the agent’s ID (e.g., an ordinary spin lock). — *end note*]
+The standard library templates `unique_lock` [[thread.lock.unique]],
+`shared_lock` [[thread.lock.shared]], `scoped_lock`
+[[thread.lock.scoped]], `lock_guard` [[thread.lock.guard]], `lock`,
+`try_lock` [[thread.lock.algorithm]], and `condition_variable_any`
+[[thread.condition.condvarany]] all operate on user-supplied lockable
+objects. The *Cpp17BasicLockable* requirements, the *Cpp17Lockable*
+requirements, and the *Cpp17TimedLockable* requirements list the
+requirements imposed by these library types in order to acquire or
+release ownership of a `lock` by a given execution agent.
 [*Note 3*: The nature of any lock ownership and any synchronization it
+entails are not part of these requirements. — *end note*]
+#### *Cpp17BasicLockable* requirements <a id="thread.req.lockable.basic">[[thread.req.lockable.basic]]</a>
+A type `L` meets the *Cpp17BasicLockable* requirements if the following
 expressions are well-formed and have the specified semantics (`m`
 denotes a value of type `L`).
 ``` cpp
 m.lock()
 ``` cpp
 m.unlock()
 ```
+*Preconditions:* The current execution agent holds a lock on `m`.
 *Effects:* Releases a lock on `m` held by the current execution agent.
 *Throws:* Nothing.
+#### *Cpp17Lockable* requirements <a id="thread.req.lockable.req">[[thread.req.lockable.req]]</a>
+A type `L` meets the *Cpp17Lockable* requirements if it meets the
+*Cpp17BasicLockable* requirements and the following expressions are
 well-formed and have the specified semantics (`m` denotes a value of
 type `L`).
 ``` cpp
 m.try_lock()
 *Return type:* `bool`.
 *Returns:* `true` if the lock was acquired, `false` otherwise.
+#### *Cpp17TimedLockable* requirements <a id="thread.req.lockable.timed">[[thread.req.lockable.timed]]</a>
+A type `L` meets the *Cpp17TimedLockable* requirements if it meets the
+*Cpp17Lockable* requirements and the following expressions are
+well-formed and have the specified semantics (`m` denotes a value of
+type `L`, `rel_time` denotes a value of an instantiation of `duration`
+[[time.duration]], and `abs_time` denotes a value of an instantiation of
+`time_point` [[time.point]]).
 ``` cpp
 m.try_lock_for(rel_time)
 ```
 *Effects:* Attempts to acquire a lock for the current execution agent
+within the relative timeout [[thread.req.timing]] specified by
+`rel_time`. The function will not return within the timeout specified by
+`rel_time` unless it has obtained a lock on `m` for the current
+execution agent. If an exception is thrown then a lock has not been
+acquired for the current execution agent.
 *Return type:* `bool`.
 *Returns:* `true` if the lock was acquired, `false` otherwise.
 ``` cpp
 m.try_lock_until(abs_time)
 ```
 *Effects:* Attempts to acquire a lock for the current execution agent
+before the absolute timeout [[thread.req.timing]] specified by
+`abs_time`. The function will not return before the timeout specified by
+`abs_time` unless it has obtained a lock on `m` for the current
+execution agent. If an exception is thrown then a lock has not been
+acquired for the current execution agent.
 *Return type:* `bool`.
 *Returns:* `true` if the lock was acquired, `false` otherwise.

Diff to HTML by rtfpessoa