Struct heron::rapier_plugin::rapier2d::crossbeam::atomic::AtomicCell
pub struct AtomicCell<T> { /* private fields */ }
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.
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>where
T: Copy + Eq,
impl<T> AtomicCell<T>where
T: Copy + Eq,
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>where
F: FnMut(T) -> Option<T>,
pub fn fetch_update<F>(&self, f: F) -> Result<T, T>where
F: FnMut(T) -> Option<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>where
T: Copy + Debug,
impl<T> Debug for AtomicCell<T>where
T: Copy + Debug,
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> Drop for AtomicCell<T>
impl<T> Drop for 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> Unpin for AtomicCell<T>where
T: Unpin,
Blanket Implementations
impl<T, U> AsBindGroupShaderType<U> for Twhere
U: ShaderType,
&'a T: for<'a> Into<U>,
impl<T, U> AsBindGroupShaderType<U> for Twhere
U: ShaderType,
&'a T: for<'a> Into<U>,
fn as_bind_group_shader_type(
&self,
_images: &HashMap<Handle<Image>, <Image as RenderAsset>::PreparedAsset, RandomState, Global>
) -> U
fn as_bind_group_shader_type(
&self,
_images: &HashMap<Handle<Image>, <Image as RenderAsset>::PreparedAsset, RandomState, Global>
) -> U
T
[ShaderType
] for self
. When used in [AsBindGroup
]
derives, it is safe to assume that all images in self
exist. Read moresourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
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
. Read morefn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
. Read morefn 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. Read morefn 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. Read moreimpl<T> FromWorld for Twhere
T: Default,
impl<T> FromWorld for Twhere
T: Default,
fn from_world(_world: &mut World) -> T
fn from_world(_world: &mut World) -> T
Self
using data from the given [World]sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
sourcefn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
impl<T> Pointable for T
impl<T> Pointable for T
impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
fn to_subset(&self) -> Option<SS>
fn to_subset(&self) -> Option<SS>
self
from the equivalent element of its
superset. Read morefn is_in_subset(&self) -> bool
fn is_in_subset(&self) -> bool
self
is actually part of its subset T
(and can be converted to it).fn to_subset_unchecked(&self) -> SS
fn to_subset_unchecked(&self) -> SS
self.to_subset
but without any property checks. Always succeeds.fn from_subset(element: &SS) -> SP
fn from_subset(element: &SS) -> SP
self
to the equivalent element of its superset.