Struct re_viewer::external::crossbeam::atomic::AtomicCell
#[repr(transparent)]pub struct AtomicCell<T> {
value: UnsafeCell<MaybeUninit<T>>,
}
Expand description
A thread-safe mutable memory location.
This type is equivalent to Cell
, except it can also be shared among multiple threads.
Operations on AtomicCell
s use atomic instructions whenever possible, and synchronize using
global locks otherwise. You can call AtomicCell::<T>::is_lock_free()
to check whether
atomic instructions or locks will be used.
Atomic loads use the Acquire
ordering and atomic stores use the Release
ordering.
Fields§
§value: UnsafeCell<MaybeUninit<T>>
Implementations§
§impl<T> AtomicCell<T>
impl<T> AtomicCell<T>
pub const fn new(val: T) -> AtomicCell<T>
pub const fn new(val: T) -> AtomicCell<T>
Creates a new atomic cell initialized with val
.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7);
pub fn into_inner(self) -> T
pub fn into_inner(self) -> T
Consumes the atomic and returns the contained value.
This is safe because passing self
by value guarantees that no other threads are
concurrently accessing the atomic data.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7);
let v = a.into_inner();
assert_eq!(v, 7);
pub const fn is_lock_free() -> bool
pub const fn is_lock_free() -> bool
Returns true
if operations on values of this type are lock-free.
If the compiler or the platform doesn’t support the necessary atomic instructions,
AtomicCell<T>
will use global locks for every potentially concurrent atomic operation.
§Examples
use crossbeam_utils::atomic::AtomicCell;
// This type is internally represented as `AtomicUsize` so we can just use atomic
// operations provided by it.
assert_eq!(AtomicCell::<usize>::is_lock_free(), true);
// A wrapper struct around `isize`.
struct Foo {
bar: isize,
}
// `AtomicCell<Foo>` will be internally represented as `AtomicIsize`.
assert_eq!(AtomicCell::<Foo>::is_lock_free(), true);
// Operations on zero-sized types are always lock-free.
assert_eq!(AtomicCell::<()>::is_lock_free(), true);
// Very large types cannot be represented as any of the standard atomic types, so atomic
// operations on them will have to use global locks for synchronization.
assert_eq!(AtomicCell::<[u8; 1000]>::is_lock_free(), false);
pub fn store(&self, val: T)
pub fn store(&self, val: T)
Stores val
into the atomic cell.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7);
assert_eq!(a.load(), 7);
a.store(8);
assert_eq!(a.load(), 8);
§impl<T> AtomicCell<T>where
T: Default,
impl<T> AtomicCell<T>where
T: Default,
§impl<T> AtomicCell<T>where
T: Copy,
impl<T> AtomicCell<T>where
T: Copy,
§impl<T> AtomicCell<T>
impl<T> AtomicCell<T>
pub fn compare_and_swap(&self, current: T, new: T) -> T
👎Deprecated: Use compare_exchange
instead
pub fn compare_and_swap(&self, current: T, new: T) -> T
compare_exchange
insteadIf the current value equals current
, stores new
into the atomic cell.
The return value is always the previous value. If it is equal to current
, then the value
was updated.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(1);
assert_eq!(a.compare_and_swap(2, 3), 1);
assert_eq!(a.load(), 1);
assert_eq!(a.compare_and_swap(1, 2), 1);
assert_eq!(a.load(), 2);
pub fn compare_exchange(&self, current: T, new: T) -> Result<T, T>
pub fn compare_exchange(&self, current: T, new: T) -> Result<T, T>
If the current value equals current
, stores new
into the atomic cell.
The return value is a result indicating whether the new value was written and containing
the previous value. On success this value is guaranteed to be equal to current
.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(1);
assert_eq!(a.compare_exchange(2, 3), Err(1));
assert_eq!(a.load(), 1);
assert_eq!(a.compare_exchange(1, 2), Ok(1));
assert_eq!(a.load(), 2);
pub fn fetch_update<F>(&self, f: F) -> Result<T, T>
pub fn fetch_update<F>(&self, f: F) -> Result<T, T>
Fetches the value, and applies a function to it that returns an optional
new value. Returns a Result
of Ok(previous_value)
if the function returned Some(_)
, else
Err(previous_value)
.
Note: This may call the function multiple times if the value has been changed from other threads in
the meantime, as long as the function returns Some(_)
, but the function will have been applied
only once to the stored value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7);
assert_eq!(a.fetch_update(|_| None), Err(7));
assert_eq!(a.fetch_update(|a| Some(a + 1)), Ok(7));
assert_eq!(a.fetch_update(|a| Some(a + 1)), Ok(8));
assert_eq!(a.load(), 9);
§impl AtomicCell<u8>
impl AtomicCell<u8>
pub fn fetch_add(&self, val: u8) -> u8
pub fn fetch_add(&self, val: u8) -> u8
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u8);
assert_eq!(a.fetch_add(3), 7);
assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: u8) -> u8
pub fn fetch_sub(&self, val: u8) -> u8
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u8);
assert_eq!(a.fetch_sub(3), 7);
assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: u8) -> u8
pub fn fetch_and(&self, val: u8) -> u8
Applies bitwise “and” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u8);
assert_eq!(a.fetch_and(3), 7);
assert_eq!(a.load(), 3);
pub fn fetch_nand(&self, val: u8) -> u8
pub fn fetch_nand(&self, val: u8) -> u8
Applies bitwise “nand” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u8);
assert_eq!(a.fetch_nand(3), 7);
assert_eq!(a.load(), !(7 & 3));
pub fn fetch_or(&self, val: u8) -> u8
pub fn fetch_or(&self, val: u8) -> u8
Applies bitwise “or” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u8);
assert_eq!(a.fetch_or(16), 7);
assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: u8) -> u8
pub fn fetch_xor(&self, val: u8) -> u8
Applies bitwise “xor” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u8);
assert_eq!(a.fetch_xor(2), 7);
assert_eq!(a.load(), 5);
§impl AtomicCell<i8>
impl AtomicCell<i8>
pub fn fetch_add(&self, val: i8) -> i8
pub fn fetch_add(&self, val: i8) -> i8
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i8);
assert_eq!(a.fetch_add(3), 7);
assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: i8) -> i8
pub fn fetch_sub(&self, val: i8) -> i8
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i8);
assert_eq!(a.fetch_sub(3), 7);
assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: i8) -> i8
pub fn fetch_and(&self, val: i8) -> i8
Applies bitwise “and” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i8);
assert_eq!(a.fetch_and(3), 7);
assert_eq!(a.load(), 3);
pub fn fetch_nand(&self, val: i8) -> i8
pub fn fetch_nand(&self, val: i8) -> i8
Applies bitwise “nand” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i8);
assert_eq!(a.fetch_nand(3), 7);
assert_eq!(a.load(), !(7 & 3));
pub fn fetch_or(&self, val: i8) -> i8
pub fn fetch_or(&self, val: i8) -> i8
Applies bitwise “or” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i8);
assert_eq!(a.fetch_or(16), 7);
assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: i8) -> i8
pub fn fetch_xor(&self, val: i8) -> i8
Applies bitwise “xor” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i8);
assert_eq!(a.fetch_xor(2), 7);
assert_eq!(a.load(), 5);
§impl AtomicCell<u16>
impl AtomicCell<u16>
pub fn fetch_add(&self, val: u16) -> u16
pub fn fetch_add(&self, val: u16) -> u16
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u16);
assert_eq!(a.fetch_add(3), 7);
assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: u16) -> u16
pub fn fetch_sub(&self, val: u16) -> u16
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u16);
assert_eq!(a.fetch_sub(3), 7);
assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: u16) -> u16
pub fn fetch_and(&self, val: u16) -> u16
Applies bitwise “and” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u16);
assert_eq!(a.fetch_and(3), 7);
assert_eq!(a.load(), 3);
pub fn fetch_nand(&self, val: u16) -> u16
pub fn fetch_nand(&self, val: u16) -> u16
Applies bitwise “nand” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u16);
assert_eq!(a.fetch_nand(3), 7);
assert_eq!(a.load(), !(7 & 3));
pub fn fetch_or(&self, val: u16) -> u16
pub fn fetch_or(&self, val: u16) -> u16
Applies bitwise “or” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u16);
assert_eq!(a.fetch_or(16), 7);
assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: u16) -> u16
pub fn fetch_xor(&self, val: u16) -> u16
Applies bitwise “xor” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u16);
assert_eq!(a.fetch_xor(2), 7);
assert_eq!(a.load(), 5);
§impl AtomicCell<i16>
impl AtomicCell<i16>
pub fn fetch_add(&self, val: i16) -> i16
pub fn fetch_add(&self, val: i16) -> i16
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i16);
assert_eq!(a.fetch_add(3), 7);
assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: i16) -> i16
pub fn fetch_sub(&self, val: i16) -> i16
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i16);
assert_eq!(a.fetch_sub(3), 7);
assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: i16) -> i16
pub fn fetch_and(&self, val: i16) -> i16
Applies bitwise “and” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i16);
assert_eq!(a.fetch_and(3), 7);
assert_eq!(a.load(), 3);
pub fn fetch_nand(&self, val: i16) -> i16
pub fn fetch_nand(&self, val: i16) -> i16
Applies bitwise “nand” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i16);
assert_eq!(a.fetch_nand(3), 7);
assert_eq!(a.load(), !(7 & 3));
pub fn fetch_or(&self, val: i16) -> i16
pub fn fetch_or(&self, val: i16) -> i16
Applies bitwise “or” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i16);
assert_eq!(a.fetch_or(16), 7);
assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: i16) -> i16
pub fn fetch_xor(&self, val: i16) -> i16
Applies bitwise “xor” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i16);
assert_eq!(a.fetch_xor(2), 7);
assert_eq!(a.load(), 5);
§impl AtomicCell<u32>
impl AtomicCell<u32>
pub fn fetch_add(&self, val: u32) -> u32
pub fn fetch_add(&self, val: u32) -> u32
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u32);
assert_eq!(a.fetch_add(3), 7);
assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: u32) -> u32
pub fn fetch_sub(&self, val: u32) -> u32
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u32);
assert_eq!(a.fetch_sub(3), 7);
assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: u32) -> u32
pub fn fetch_and(&self, val: u32) -> u32
Applies bitwise “and” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u32);
assert_eq!(a.fetch_and(3), 7);
assert_eq!(a.load(), 3);
pub fn fetch_nand(&self, val: u32) -> u32
pub fn fetch_nand(&self, val: u32) -> u32
Applies bitwise “nand” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u32);
assert_eq!(a.fetch_nand(3), 7);
assert_eq!(a.load(), !(7 & 3));
pub fn fetch_or(&self, val: u32) -> u32
pub fn fetch_or(&self, val: u32) -> u32
Applies bitwise “or” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u32);
assert_eq!(a.fetch_or(16), 7);
assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: u32) -> u32
pub fn fetch_xor(&self, val: u32) -> u32
Applies bitwise “xor” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u32);
assert_eq!(a.fetch_xor(2), 7);
assert_eq!(a.load(), 5);
§impl AtomicCell<i32>
impl AtomicCell<i32>
pub fn fetch_add(&self, val: i32) -> i32
pub fn fetch_add(&self, val: i32) -> i32
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i32);
assert_eq!(a.fetch_add(3), 7);
assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: i32) -> i32
pub fn fetch_sub(&self, val: i32) -> i32
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i32);
assert_eq!(a.fetch_sub(3), 7);
assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: i32) -> i32
pub fn fetch_and(&self, val: i32) -> i32
Applies bitwise “and” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i32);
assert_eq!(a.fetch_and(3), 7);
assert_eq!(a.load(), 3);
pub fn fetch_nand(&self, val: i32) -> i32
pub fn fetch_nand(&self, val: i32) -> i32
Applies bitwise “nand” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i32);
assert_eq!(a.fetch_nand(3), 7);
assert_eq!(a.load(), !(7 & 3));
pub fn fetch_or(&self, val: i32) -> i32
pub fn fetch_or(&self, val: i32) -> i32
Applies bitwise “or” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i32);
assert_eq!(a.fetch_or(16), 7);
assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: i32) -> i32
pub fn fetch_xor(&self, val: i32) -> i32
Applies bitwise “xor” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i32);
assert_eq!(a.fetch_xor(2), 7);
assert_eq!(a.load(), 5);
§impl AtomicCell<u64>
impl AtomicCell<u64>
pub fn fetch_add(&self, val: u64) -> u64
pub fn fetch_add(&self, val: u64) -> u64
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u64);
assert_eq!(a.fetch_add(3), 7);
assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: u64) -> u64
pub fn fetch_sub(&self, val: u64) -> u64
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u64);
assert_eq!(a.fetch_sub(3), 7);
assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: u64) -> u64
pub fn fetch_and(&self, val: u64) -> u64
Applies bitwise “and” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u64);
assert_eq!(a.fetch_and(3), 7);
assert_eq!(a.load(), 3);
pub fn fetch_nand(&self, val: u64) -> u64
pub fn fetch_nand(&self, val: u64) -> u64
Applies bitwise “nand” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u64);
assert_eq!(a.fetch_nand(3), 7);
assert_eq!(a.load(), !(7 & 3));
pub fn fetch_or(&self, val: u64) -> u64
pub fn fetch_or(&self, val: u64) -> u64
Applies bitwise “or” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u64);
assert_eq!(a.fetch_or(16), 7);
assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: u64) -> u64
pub fn fetch_xor(&self, val: u64) -> u64
Applies bitwise “xor” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u64);
assert_eq!(a.fetch_xor(2), 7);
assert_eq!(a.load(), 5);
§impl AtomicCell<i64>
impl AtomicCell<i64>
pub fn fetch_add(&self, val: i64) -> i64
pub fn fetch_add(&self, val: i64) -> i64
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i64);
assert_eq!(a.fetch_add(3), 7);
assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: i64) -> i64
pub fn fetch_sub(&self, val: i64) -> i64
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i64);
assert_eq!(a.fetch_sub(3), 7);
assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: i64) -> i64
pub fn fetch_and(&self, val: i64) -> i64
Applies bitwise “and” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i64);
assert_eq!(a.fetch_and(3), 7);
assert_eq!(a.load(), 3);
pub fn fetch_nand(&self, val: i64) -> i64
pub fn fetch_nand(&self, val: i64) -> i64
Applies bitwise “nand” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i64);
assert_eq!(a.fetch_nand(3), 7);
assert_eq!(a.load(), !(7 & 3));
pub fn fetch_or(&self, val: i64) -> i64
pub fn fetch_or(&self, val: i64) -> i64
Applies bitwise “or” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i64);
assert_eq!(a.fetch_or(16), 7);
assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: i64) -> i64
pub fn fetch_xor(&self, val: i64) -> i64
Applies bitwise “xor” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i64);
assert_eq!(a.fetch_xor(2), 7);
assert_eq!(a.load(), 5);
§impl AtomicCell<u128>
impl AtomicCell<u128>
pub fn fetch_add(&self, val: u128) -> u128
pub fn fetch_add(&self, val: u128) -> u128
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u128);
assert_eq!(a.fetch_add(3), 7);
assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: u128) -> u128
pub fn fetch_sub(&self, val: u128) -> u128
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u128);
assert_eq!(a.fetch_sub(3), 7);
assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: u128) -> u128
pub fn fetch_and(&self, val: u128) -> u128
Applies bitwise “and” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u128);
assert_eq!(a.fetch_and(3), 7);
assert_eq!(a.load(), 3);
pub fn fetch_nand(&self, val: u128) -> u128
pub fn fetch_nand(&self, val: u128) -> u128
Applies bitwise “nand” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u128);
assert_eq!(a.fetch_nand(3), 7);
assert_eq!(a.load(), !(7 & 3));
pub fn fetch_or(&self, val: u128) -> u128
pub fn fetch_or(&self, val: u128) -> u128
Applies bitwise “or” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u128);
assert_eq!(a.fetch_or(16), 7);
assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: u128) -> u128
pub fn fetch_xor(&self, val: u128) -> u128
Applies bitwise “xor” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7u128);
assert_eq!(a.fetch_xor(2), 7);
assert_eq!(a.load(), 5);
§impl AtomicCell<i128>
impl AtomicCell<i128>
pub fn fetch_add(&self, val: i128) -> i128
pub fn fetch_add(&self, val: i128) -> i128
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i128);
assert_eq!(a.fetch_add(3), 7);
assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: i128) -> i128
pub fn fetch_sub(&self, val: i128) -> i128
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i128);
assert_eq!(a.fetch_sub(3), 7);
assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: i128) -> i128
pub fn fetch_and(&self, val: i128) -> i128
Applies bitwise “and” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i128);
assert_eq!(a.fetch_and(3), 7);
assert_eq!(a.load(), 3);
pub fn fetch_nand(&self, val: i128) -> i128
pub fn fetch_nand(&self, val: i128) -> i128
Applies bitwise “nand” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i128);
assert_eq!(a.fetch_nand(3), 7);
assert_eq!(a.load(), !(7 & 3));
pub fn fetch_or(&self, val: i128) -> i128
pub fn fetch_or(&self, val: i128) -> i128
Applies bitwise “or” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i128);
assert_eq!(a.fetch_or(16), 7);
assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: i128) -> i128
pub fn fetch_xor(&self, val: i128) -> i128
Applies bitwise “xor” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7i128);
assert_eq!(a.fetch_xor(2), 7);
assert_eq!(a.load(), 5);
§impl AtomicCell<usize>
impl AtomicCell<usize>
pub fn fetch_add(&self, val: usize) -> usize
pub fn fetch_add(&self, val: usize) -> usize
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7usize);
assert_eq!(a.fetch_add(3), 7);
assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: usize) -> usize
pub fn fetch_sub(&self, val: usize) -> usize
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7usize);
assert_eq!(a.fetch_sub(3), 7);
assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: usize) -> usize
pub fn fetch_and(&self, val: usize) -> usize
Applies bitwise “and” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7usize);
assert_eq!(a.fetch_and(3), 7);
assert_eq!(a.load(), 3);
pub fn fetch_nand(&self, val: usize) -> usize
pub fn fetch_nand(&self, val: usize) -> usize
Applies bitwise “nand” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7usize);
assert_eq!(a.fetch_nand(3), 7);
assert_eq!(a.load(), !(7 & 3));
pub fn fetch_or(&self, val: usize) -> usize
pub fn fetch_or(&self, val: usize) -> usize
Applies bitwise “or” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7usize);
assert_eq!(a.fetch_or(16), 7);
assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: usize) -> usize
pub fn fetch_xor(&self, val: usize) -> usize
Applies bitwise “xor” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7usize);
assert_eq!(a.fetch_xor(2), 7);
assert_eq!(a.load(), 5);
§impl AtomicCell<isize>
impl AtomicCell<isize>
pub fn fetch_add(&self, val: isize) -> isize
pub fn fetch_add(&self, val: isize) -> isize
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7isize);
assert_eq!(a.fetch_add(3), 7);
assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: isize) -> isize
pub fn fetch_sub(&self, val: isize) -> isize
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7isize);
assert_eq!(a.fetch_sub(3), 7);
assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: isize) -> isize
pub fn fetch_and(&self, val: isize) -> isize
Applies bitwise “and” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7isize);
assert_eq!(a.fetch_and(3), 7);
assert_eq!(a.load(), 3);
pub fn fetch_nand(&self, val: isize) -> isize
pub fn fetch_nand(&self, val: isize) -> isize
Applies bitwise “nand” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7isize);
assert_eq!(a.fetch_nand(3), 7);
assert_eq!(a.load(), !(7 & 3));
pub fn fetch_or(&self, val: isize) -> isize
pub fn fetch_or(&self, val: isize) -> isize
Applies bitwise “or” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7isize);
assert_eq!(a.fetch_or(16), 7);
assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: isize) -> isize
pub fn fetch_xor(&self, val: isize) -> isize
Applies bitwise “xor” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(7isize);
assert_eq!(a.fetch_xor(2), 7);
assert_eq!(a.load(), 5);
§impl AtomicCell<bool>
impl AtomicCell<bool>
pub fn fetch_and(&self, val: bool) -> bool
pub fn fetch_and(&self, val: bool) -> bool
Applies logical “and” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(true);
assert_eq!(a.fetch_and(true), true);
assert_eq!(a.load(), true);
assert_eq!(a.fetch_and(false), true);
assert_eq!(a.load(), false);
pub fn fetch_nand(&self, val: bool) -> bool
pub fn fetch_nand(&self, val: bool) -> bool
Applies logical “nand” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(true);
assert_eq!(a.fetch_nand(false), true);
assert_eq!(a.load(), true);
assert_eq!(a.fetch_nand(true), true);
assert_eq!(a.load(), false);
assert_eq!(a.fetch_nand(false), false);
assert_eq!(a.load(), true);
pub fn fetch_or(&self, val: bool) -> bool
pub fn fetch_or(&self, val: bool) -> bool
Applies logical “or” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(false);
assert_eq!(a.fetch_or(false), false);
assert_eq!(a.load(), false);
assert_eq!(a.fetch_or(true), false);
assert_eq!(a.load(), true);
pub fn fetch_xor(&self, val: bool) -> bool
pub fn fetch_xor(&self, val: bool) -> bool
Applies logical “xor” to the current value and returns the previous value.
§Examples
use crossbeam_utils::atomic::AtomicCell;
let a = AtomicCell::new(true);
assert_eq!(a.fetch_xor(false), true);
assert_eq!(a.load(), true);
assert_eq!(a.fetch_xor(true), true);
assert_eq!(a.load(), false);
Trait Implementations§
§impl<T> Debug for AtomicCell<T>
impl<T> Debug for AtomicCell<T>
§impl<T> Default for AtomicCell<T>where
T: Default,
impl<T> Default for AtomicCell<T>where
T: Default,
§fn default() -> AtomicCell<T>
fn default() -> AtomicCell<T>
§impl<T> From<T> for AtomicCell<T>
impl<T> From<T> for AtomicCell<T>
§fn from(val: T) -> AtomicCell<T>
fn from(val: T) -> AtomicCell<T>
impl<T> RefUnwindSafe for AtomicCell<T>
impl<T> Send for AtomicCell<T>where
T: Send,
impl<T> Sync for AtomicCell<T>where
T: Send,
impl<T> UnwindSafe for AtomicCell<T>
Auto Trait Implementations§
impl<T> !Freeze for AtomicCell<T>
impl<T> Unpin for AtomicCell<T>where
T: Unpin,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CheckedAs for T
impl<T> CheckedAs for T
source§fn checked_as<Dst>(self) -> Option<Dst>where
T: CheckedCast<Dst>,
fn checked_as<Dst>(self) -> Option<Dst>where
T: CheckedCast<Dst>,
source§impl<Src, Dst> CheckedCastFrom<Src> for Dstwhere
Src: CheckedCast<Dst>,
impl<Src, Dst> CheckedCastFrom<Src> for Dstwhere
Src: CheckedCast<Dst>,
source§fn checked_cast_from(src: Src) -> Option<Dst>
fn checked_cast_from(src: Src) -> Option<Dst>
§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
.§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.§impl<T> DowncastSync for T
impl<T> DowncastSync for T
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§impl<T> IntoRequest<T> for T
impl<T> IntoRequest<T> for T
source§fn into_request(self) -> Request<T>
fn into_request(self) -> Request<T>
T
in a tonic::Request