nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-24 15:54:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

Improve documentation on success and failure arguments

Browse Source
This commit is contained in:
Linus Färnstrand 2020-11-22 20:36:29 +01:00
parent 427996a286
commit 3eef20ffa0
1 changed files with 24 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
library/core/src/sync/atomic.rs
View File

@ -514,9 +514,10 @@ impl AtomicBool {
/// the previous value. On success this value is guaranteed to be equal to `current`. /// the previous value. On success this value is guaranteed to be equal to `current`.
/// ///
/// `compare_exchange` takes two [`Ordering`] arguments to describe the memory /// `compare_exchange` takes two [`Ordering`] arguments to describe the memory
/// ordering of this operation. The first describes the required ordering if the /// ordering of this operation. `success` describes the required ordering for the
/// operation succeeds while the second describes the required ordering when the /// read-modify-write operation that takes place if the comparison with `current` succeeds.
/// operation fails. Using [`Acquire`] as success ordering makes the store part /// `failure` describes the required ordering for the load operation that takes place when
/// the comparison fails. Using [`Acquire`] as success ordering makes the store part
/// of this operation [`Relaxed`], and using [`Release`] makes the successful load /// of this operation [`Relaxed`], and using [`Release`] makes the successful load
/// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`] /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]
/// and must be equivalent to or weaker than the success ordering. /// and must be equivalent to or weaker than the success ordering.
@ -572,9 +573,10 @@ impl AtomicBool {
/// previous value. /// previous value.
/// ///
/// `compare_exchange_weak` takes two [`Ordering`] arguments to describe the memory /// `compare_exchange_weak` takes two [`Ordering`] arguments to describe the memory
/// ordering of this operation. The first describes the required ordering if the /// ordering of this operation. `success` describes the required ordering for the
/// operation succeeds while the second describes the required ordering when the /// read-modify-write operation that takes place if the comparison with `current` succeeds.
/// operation fails. Using [`Acquire`] as success ordering makes the store part /// `failure` describes the required ordering for the load operation that takes place when
/// the comparison fails. Using [`Acquire`] as success ordering makes the store part
/// of this operation [`Relaxed`], and using [`Release`] makes the successful load /// of this operation [`Relaxed`], and using [`Release`] makes the successful load
/// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`] /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]
/// and must be equivalent to or weaker than the success ordering. /// and must be equivalent to or weaker than the success ordering.
@ -1138,9 +1140,10 @@ impl<T> AtomicPtr<T> {
/// the previous value. On success this value is guaranteed to be equal to `current`. /// the previous value. On success this value is guaranteed to be equal to `current`.
/// ///
/// `compare_exchange` takes two [`Ordering`] arguments to describe the memory /// `compare_exchange` takes two [`Ordering`] arguments to describe the memory
/// ordering of this operation. The first describes the required ordering if the /// ordering of this operation. `success` describes the required ordering for the
/// operation succeeds while the second describes the required ordering when the /// read-modify-write operation that takes place if the comparison with `current` succeeds.
/// operation fails. Using [`Acquire`] as success ordering makes the store part /// `failure` describes the required ordering for the load operation that takes place when
/// the comparison fails. Using [`Acquire`] as success ordering makes the store part
/// of this operation [`Relaxed`], and using [`Release`] makes the successful load /// of this operation [`Relaxed`], and using [`Release`] makes the successful load
/// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`] /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]
/// and must be equivalent to or weaker than the success ordering. /// and must be equivalent to or weaker than the success ordering.
@ -1201,9 +1204,10 @@ impl<T> AtomicPtr<T> {
/// previous value. /// previous value.
/// ///
/// `compare_exchange_weak` takes two [`Ordering`] arguments to describe the memory /// `compare_exchange_weak` takes two [`Ordering`] arguments to describe the memory
/// ordering of this operation. The first describes the required ordering if the /// ordering of this operation. `success` describes the required ordering for the
/// operation succeeds while the second describes the required ordering when the /// read-modify-write operation that takes place if the comparison with `current` succeeds.
/// operation fails. Using [`Acquire`] as success ordering makes the store part /// `failure` describes the required ordering for the load operation that takes place when
/// the comparison fails. Using [`Acquire`] as success ordering makes the store part
/// of this operation [`Relaxed`], and using [`Release`] makes the successful load /// of this operation [`Relaxed`], and using [`Release`] makes the successful load
/// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`] /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]
/// and must be equivalent to or weaker than the success ordering. /// and must be equivalent to or weaker than the success ordering.
@ -1708,9 +1712,10 @@ containing the previous value. On success this value is guaranteed to be equal t
`current`. `current`.
`compare_exchange` takes two [`Ordering`] arguments to describe the memory `compare_exchange` takes two [`Ordering`] arguments to describe the memory
ordering of this operation. The first describes the required ordering if the ordering of this operation. `success` describes the required ordering for the
operation succeeds while the second describes the required ordering when the read-modify-write operation that takes place if the comparison with `current` succeeds.
operation fails. Using [`Acquire`] as success ordering makes the store part `failure` describes the required ordering for the load operation that takes place when
the comparison fails. Using [`Acquire`] as success ordering makes the store part
of this operation [`Relaxed`], and using [`Release`] makes the successful load of this operation [`Relaxed`], and using [`Release`] makes the successful load
[`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`] [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]
and must be equivalent to or weaker than the success ordering. and must be equivalent to or weaker than the success ordering.
@ -1760,9 +1765,10 @@ platforms. The return value is a result indicating whether the new value was
written and containing the previous value. written and containing the previous value.
`compare_exchange_weak` takes two [`Ordering`] arguments to describe the memory `compare_exchange_weak` takes two [`Ordering`] arguments to describe the memory
ordering of this operation. The first describes the required ordering if the ordering of this operation. `success` describes the required ordering for the
operation succeeds while the second describes the required ordering when the read-modify-write operation that takes place if the comparison with `current` succeeds.
operation fails. Using [`Acquire`] as success ordering makes the store part `failure` describes the required ordering for the load operation that takes place when
the comparison fails. Using [`Acquire`] as success ordering makes the store part
of this operation [`Relaxed`], and using [`Release`] makes the successful load of this operation [`Relaxed`], and using [`Release`] makes the successful load
[`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`] [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]
and must be equivalent to or weaker than the success ordering. and must be equivalent to or weaker than the success ordering.