Struct std::sync::atomic::AtomicBool
[−]
[src]
pub struct AtomicBool {
// some fields omitted
}A boolean type which can be safely shared between threads.
Methods
impl AtomicBool
fn new(v: bool) -> AtomicBool
Creates a new AtomicBool`AtomicBool`.
Examples
fn main() { use std::sync::atomic::AtomicBool; let atomic_true = AtomicBool::new(true); let atomic_false = AtomicBool::new(false); }use std::sync::atomic::AtomicBool; let atomic_true = AtomicBool::new(true); let atomic_false = AtomicBool::new(false);
fn load(&self, order: Ordering) -> bool
Loads a value from the bool.
load`loadtakes an` takes an Ordering`Ordering` argument which describes the memory ordering of this operation.
Panics
Panics if order`orderis` is Release`Releaseor` or AcqRel`AcqRel`.
Examples
fn main() { use std::sync::atomic::{AtomicBool, Ordering}; let some_bool = AtomicBool::new(true); let value = some_bool.load(Ordering::Relaxed); }use std::sync::atomic::{AtomicBool, Ordering}; let some_bool = AtomicBool::new(true); let value = some_bool.load(Ordering::Relaxed);
fn store(&self, val: bool, order: Ordering)
Stores a value into the bool.
store`storetakes an` takes an Ordering`Ordering` argument which describes the memory ordering of this operation.
Examples
fn main() { use std::sync::atomic::{AtomicBool, Ordering}; let some_bool = AtomicBool::new(true); some_bool.store(false, Ordering::Relaxed); }use std::sync::atomic::{AtomicBool, Ordering}; let some_bool = AtomicBool::new(true); some_bool.store(false, Ordering::Relaxed);
Panics
Panics if order`orderis` is Acquire`Acquireor` or AcqRel`AcqRel`.
fn swap(&self, val: bool, order: Ordering) -> bool
Stores a value into the bool, returning the old value.
swap`swaptakes an` takes an Ordering`Ordering` argument which describes the memory ordering of this operation.
Examples
fn main() { use std::sync::atomic::{AtomicBool, Ordering}; let some_bool = AtomicBool::new(true); let value = some_bool.swap(false, Ordering::Relaxed); }use std::sync::atomic::{AtomicBool, Ordering}; let some_bool = AtomicBool::new(true); let value = some_bool.swap(false, Ordering::Relaxed);
fn compare_and_swap(&self, old: bool, new: bool, order: Ordering) -> bool
Stores a value into the bool if the current value is the same as the expected value.
The return value is always the previous value. If it is equal to old`old`, then the value was
updated.
swap`swapalso takes an` also takes an Ordering`Ordering` argument which describes the memory ordering of this
operation.
Examples
fn main() { use std::sync::atomic::{AtomicBool, Ordering}; let some_bool = AtomicBool::new(true); let value = some_bool.store(false, Ordering::Relaxed); }use std::sync::atomic::{AtomicBool, Ordering}; let some_bool = AtomicBool::new(true); let value = some_bool.store(false, Ordering::Relaxed);
fn fetch_and(&self, val: bool, order: Ordering) -> bool
Logical "and" with a boolean value.
Performs a logical "and" operation on the current value and the argument val`val`, and sets
the new value to the result.
Returns the previous value.
Examples
fn main() { use std::sync::atomic::{AtomicBool, Ordering}; let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_and(false, Ordering::SeqCst)); assert_eq!(false, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_and(true, Ordering::SeqCst)); assert_eq!(true, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(false); assert_eq!(false, foo.fetch_and(false, Ordering::SeqCst)); assert_eq!(false, foo.load(Ordering::SeqCst)); }use std::sync::atomic::{AtomicBool, Ordering}; let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_and(false, Ordering::SeqCst)); assert_eq!(false, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_and(true, Ordering::SeqCst)); assert_eq!(true, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(false); assert_eq!(false, foo.fetch_and(false, Ordering::SeqCst)); assert_eq!(false, foo.load(Ordering::SeqCst));
fn fetch_nand(&self, val: bool, order: Ordering) -> bool
Logical "nand" with a boolean value.
Performs a logical "nand" operation on the current value and the argument val`val`, and sets
the new value to the result.
Returns the previous value.
Examples
fn main() { use std::sync::atomic::{AtomicBool, Ordering}; let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_nand(false, Ordering::SeqCst)); assert_eq!(true, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_nand(true, Ordering::SeqCst)); assert_eq!(0, foo.load(Ordering::SeqCst) as usize); assert_eq!(false, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(false); assert_eq!(false, foo.fetch_nand(false, Ordering::SeqCst)); assert_eq!(true, foo.load(Ordering::SeqCst)); }use std::sync::atomic::{AtomicBool, Ordering}; let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_nand(false, Ordering::SeqCst)); assert_eq!(true, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_nand(true, Ordering::SeqCst)); assert_eq!(0, foo.load(Ordering::SeqCst) as usize); assert_eq!(false, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(false); assert_eq!(false, foo.fetch_nand(false, Ordering::SeqCst)); assert_eq!(true, foo.load(Ordering::SeqCst));
fn fetch_or(&self, val: bool, order: Ordering) -> bool
Logical "or" with a boolean value.
Performs a logical "or" operation on the current value and the argument val`val`, and sets the
new value to the result.
Returns the previous value.
Examples
fn main() { use std::sync::atomic::{AtomicBool, Ordering}; let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_or(false, Ordering::SeqCst)); assert_eq!(true, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_or(true, Ordering::SeqCst)); assert_eq!(true, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(false); assert_eq!(false, foo.fetch_or(false, Ordering::SeqCst)); assert_eq!(false, foo.load(Ordering::SeqCst)); }use std::sync::atomic::{AtomicBool, Ordering}; let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_or(false, Ordering::SeqCst)); assert_eq!(true, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_or(true, Ordering::SeqCst)); assert_eq!(true, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(false); assert_eq!(false, foo.fetch_or(false, Ordering::SeqCst)); assert_eq!(false, foo.load(Ordering::SeqCst));
fn fetch_xor(&self, val: bool, order: Ordering) -> bool
Logical "xor" with a boolean value.
Performs a logical "xor" operation on the current value and the argument val`val`, and sets
the new value to the result.
Returns the previous value.
Examples
fn main() { use std::sync::atomic::{AtomicBool, Ordering}; let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_xor(false, Ordering::SeqCst)); assert_eq!(true, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_xor(true, Ordering::SeqCst)); assert_eq!(false, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(false); assert_eq!(false, foo.fetch_xor(false, Ordering::SeqCst)); assert_eq!(false, foo.load(Ordering::SeqCst)); }use std::sync::atomic::{AtomicBool, Ordering}; let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_xor(false, Ordering::SeqCst)); assert_eq!(true, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_xor(true, Ordering::SeqCst)); assert_eq!(false, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(false); assert_eq!(false, foo.fetch_xor(false, Ordering::SeqCst)); assert_eq!(false, foo.load(Ordering::SeqCst));