Struct std::sync::atomic::AtomicBool
[−]
[src]
pub struct AtomicBool { v: UnsafeCell<usize>, }
A boolean type which can be safely shared between threads.
Fields
v |
Methods
impl AtomicBool
const fn new(v: bool) -> AtomicBool
Creates a new AtomicBool
.
Examples
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
takes an Ordering
argument which describes the memory ordering of this operation.
Panics
Panics if order
is Release
or AcqRel
.
Examples
use std::sync::atomic::{AtomicBool, Ordering}; let some_bool = AtomicBool::new(true); assert_eq!(some_bool.load(Ordering::Relaxed), true);
fn store(&self, val: bool, order: Ordering)
Stores a value into the bool.
store
takes an Ordering
argument which describes the memory ordering of this operation.
Examples
use std::sync::atomic::{AtomicBool, Ordering}; let some_bool = AtomicBool::new(true); some_bool.store(false, Ordering::Relaxed); assert_eq!(some_bool.load(Ordering::Relaxed), false);
Panics
Panics if order
is Acquire
or AcqRel
.
fn swap(&self, val: bool, order: Ordering) -> bool
Stores a value into the bool, returning the old value.
swap
takes an Ordering
argument which describes the memory ordering of this operation.
Examples
use std::sync::atomic::{AtomicBool, Ordering}; let some_bool = AtomicBool::new(true); assert_eq!(some_bool.swap(false, Ordering::Relaxed), true); assert_eq!(some_bool.load(Ordering::Relaxed), false);
fn compare_and_swap(&self, current: bool, new: bool, order: Ordering) -> bool
Stores a value into the bool
if the current value is the same as the current
value.
The return value is always the previous value. If it is equal to current
, then the value
was updated.
compare_and_swap
also takes an Ordering
argument which describes the memory ordering of
this operation.
Examples
use std::sync::atomic::{AtomicBool, Ordering}; let some_bool = AtomicBool::new(true); assert_eq!(some_bool.compare_and_swap(true, false, Ordering::Relaxed), true); assert_eq!(some_bool.load(Ordering::Relaxed), false); assert_eq!(some_bool.compare_and_swap(true, true, Ordering::Relaxed), false); assert_eq!(some_bool.load(Ordering::Relaxed), false);
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
, and sets
the new value to the result.
Returns the previous value.
Examples
use std::sync::atomic::{AtomicBool, Ordering}; let foo = AtomicBool::new(true); assert_eq!(foo.fetch_and(false, Ordering::SeqCst), true); assert_eq!(foo.load(Ordering::SeqCst), false); let foo = AtomicBool::new(true); assert_eq!(foo.fetch_and(true, Ordering::SeqCst), true); assert_eq!(foo.load(Ordering::SeqCst), true); let foo = AtomicBool::new(false); assert_eq!(foo.fetch_and(false, Ordering::SeqCst), false); assert_eq!(foo.load(Ordering::SeqCst), false);
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
, and sets
the new value to the result.
Returns the previous value.
Examples
use std::sync::atomic::{AtomicBool, Ordering}; let foo = AtomicBool::new(true); assert_eq!(foo.fetch_nand(false, Ordering::SeqCst), true); assert_eq!(foo.load(Ordering::SeqCst), true); let foo = AtomicBool::new(true); assert_eq!(foo.fetch_nand(true, Ordering::SeqCst), true); assert_eq!(foo.load(Ordering::SeqCst) as usize, 0); assert_eq!(foo.load(Ordering::SeqCst), false); let foo = AtomicBool::new(false); assert_eq!(foo.fetch_nand(false, Ordering::SeqCst), false); assert_eq!(foo.load(Ordering::SeqCst), true);
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
, and sets the
new value to the result.
Returns the previous value.
Examples
use std::sync::atomic::{AtomicBool, Ordering}; let foo = AtomicBool::new(true); assert_eq!(foo.fetch_or(false, Ordering::SeqCst), true); assert_eq!(foo.load(Ordering::SeqCst), true); let foo = AtomicBool::new(true); assert_eq!(foo.fetch_or(true, Ordering::SeqCst), true); assert_eq!(foo.load(Ordering::SeqCst), true); let foo = AtomicBool::new(false); assert_eq!(foo.fetch_or(false, Ordering::SeqCst), false); assert_eq!(foo.load(Ordering::SeqCst), false);
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
, and sets
the new value to the result.
Returns the previous value.
Examples
use std::sync::atomic::{AtomicBool, Ordering}; let foo = AtomicBool::new(true); assert_eq!(foo.fetch_xor(false, Ordering::SeqCst), true); assert_eq!(foo.load(Ordering::SeqCst), true); let foo = AtomicBool::new(true); assert_eq!(foo.fetch_xor(true, Ordering::SeqCst), true); assert_eq!(foo.load(Ordering::SeqCst), false); let foo = AtomicBool::new(false); assert_eq!(foo.fetch_xor(false, Ordering::SeqCst), false); assert_eq!(foo.load(Ordering::SeqCst), false);