Struct crossbeam::atomic::AtomicCell [−][src]
#[repr(transparent)]pub struct AtomicCell<T> where
T: ?Sized, { /* fields omitted */ }
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>
[src]
impl<T> AtomicCell<T>
[src]pub const fn new(val: T) -> AtomicCell<T>
[src]
pub const fn new(val: T) -> AtomicCell<T>
[src]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
[src]
pub fn into_inner(self) -> T
[src]Consumes the atomic and returns the contained value.
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
[src]
pub const fn is_lock_free() -> bool
[src]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);
impl<T> AtomicCell<T> where
T: ?Sized,
[src]
impl<T> AtomicCell<T> where
T: ?Sized,
[src]impl<T> AtomicCell<T> where
T: Default,
[src]
impl<T> AtomicCell<T> where
T: Default,
[src]impl<T> AtomicCell<T> where
T: Copy,
[src]
impl<T> AtomicCell<T> where
T: Copy,
[src]impl<T> AtomicCell<T> where
T: Copy + Eq,
[src]
impl<T> AtomicCell<T> where
T: Copy + Eq,
[src]pub fn compare_and_swap(&self, current: T, new: T) -> T
[src]
👎 Deprecated: Use compare_exchange
instead
pub fn compare_and_swap(&self, current: T, new: T) -> T
[src]Use compare_exchange
instead
If 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>
[src]
pub fn compare_exchange(&self, current: T, new: T) -> Result<T, T>
[src]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>,
[src]
pub fn fetch_update<F>(&self, f: F) -> Result<T, T> where
F: FnMut(T) -> Option<T>,
[src]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<bool>
[src]
impl AtomicCell<bool>
[src]pub fn fetch_and(&self, val: bool) -> bool
[src]
pub fn fetch_and(&self, val: bool) -> bool
[src]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_or(&self, val: bool) -> bool
[src]
pub fn fetch_or(&self, val: bool) -> bool
[src]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
[src]
pub fn fetch_xor(&self, val: bool) -> bool
[src]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);
impl AtomicCell<u8>
[src]
impl AtomicCell<u8>
[src]pub fn fetch_add(&self, val: u8) -> u8
[src]
pub fn fetch_add(&self, val: u8) -> u8
[src]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
[src]
pub fn fetch_sub(&self, val: u8) -> u8
[src]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
[src]
pub fn fetch_and(&self, val: u8) -> u8
[src]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);
impl AtomicCell<i8>
[src]
impl AtomicCell<i8>
[src]pub fn fetch_add(&self, val: i8) -> i8
[src]
pub fn fetch_add(&self, val: i8) -> i8
[src]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
[src]
pub fn fetch_sub(&self, val: i8) -> i8
[src]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
[src]
pub fn fetch_and(&self, val: i8) -> i8
[src]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);
impl AtomicCell<u16>
[src]
impl AtomicCell<u16>
[src]pub fn fetch_add(&self, val: u16) -> u16
[src]
pub fn fetch_add(&self, val: u16) -> u16
[src]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
[src]
pub fn fetch_sub(&self, val: u16) -> u16
[src]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
[src]
pub fn fetch_and(&self, val: u16) -> u16
[src]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);
impl AtomicCell<i16>
[src]
impl AtomicCell<i16>
[src]pub fn fetch_add(&self, val: i16) -> i16
[src]
pub fn fetch_add(&self, val: i16) -> i16
[src]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
[src]
pub fn fetch_sub(&self, val: i16) -> i16
[src]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
[src]
pub fn fetch_and(&self, val: i16) -> i16
[src]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);
impl AtomicCell<u32>
[src]
impl AtomicCell<u32>
[src]pub fn fetch_add(&self, val: u32) -> u32
[src]
pub fn fetch_add(&self, val: u32) -> u32
[src]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
[src]
pub fn fetch_sub(&self, val: u32) -> u32
[src]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
[src]
pub fn fetch_and(&self, val: u32) -> u32
[src]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);
impl AtomicCell<i32>
[src]
impl AtomicCell<i32>
[src]pub fn fetch_add(&self, val: i32) -> i32
[src]
pub fn fetch_add(&self, val: i32) -> i32
[src]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
[src]
pub fn fetch_sub(&self, val: i32) -> i32
[src]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
[src]
pub fn fetch_and(&self, val: i32) -> i32
[src]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);
impl AtomicCell<u64>
[src]
impl AtomicCell<u64>
[src]pub fn fetch_add(&self, val: u64) -> u64
[src]
pub fn fetch_add(&self, val: u64) -> u64
[src]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
[src]
pub fn fetch_sub(&self, val: u64) -> u64
[src]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
[src]
pub fn fetch_and(&self, val: u64) -> u64
[src]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);
impl AtomicCell<i64>
[src]
impl AtomicCell<i64>
[src]pub fn fetch_add(&self, val: i64) -> i64
[src]
pub fn fetch_add(&self, val: i64) -> i64
[src]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
[src]
pub fn fetch_sub(&self, val: i64) -> i64
[src]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
[src]
pub fn fetch_and(&self, val: i64) -> i64
[src]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);
impl AtomicCell<usize>
[src]
impl AtomicCell<usize>
[src]pub fn fetch_add(&self, val: usize) -> usize
[src]
pub fn fetch_add(&self, val: usize) -> usize
[src]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
[src]
pub fn fetch_sub(&self, val: usize) -> usize
[src]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
[src]
pub fn fetch_and(&self, val: usize) -> usize
[src]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);
impl AtomicCell<isize>
[src]
impl AtomicCell<isize>
[src]pub fn fetch_add(&self, val: isize) -> isize
[src]
pub fn fetch_add(&self, val: isize) -> isize
[src]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
[src]
pub fn fetch_sub(&self, val: isize) -> isize
[src]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
[src]
pub fn fetch_and(&self, val: isize) -> isize
[src]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);
Trait Implementations
impl<T> Debug for AtomicCell<T> where
T: Copy + Debug,
[src]
impl<T> Debug for AtomicCell<T> where
T: Copy + Debug,
[src]impl<T> Default for AtomicCell<T> where
T: Default,
[src]
impl<T> Default for AtomicCell<T> where
T: Default,
[src]pub fn default() -> AtomicCell<T>
[src]
pub fn default() -> AtomicCell<T>
[src]Returns the “default value” for a type. Read more
impl<T> From<T> for AtomicCell<T>
[src]
impl<T> From<T> for AtomicCell<T>
[src]pub fn from(val: T) -> AtomicCell<T>
[src]
pub fn from(val: T) -> AtomicCell<T>
[src]Performs the conversion.
impl<T> RefUnwindSafe for AtomicCell<T>
[src]
impl<T> Send for AtomicCell<T> where
T: Send,
[src]
T: Send,
impl<T> Sync for AtomicCell<T> where
T: Send,
[src]
T: Send,
impl<T> UnwindSafe for AtomicCell<T>
[src]
Auto Trait Implementations
impl<T: ?Sized> Unpin for AtomicCell<T> where
T: Unpin,
T: Unpin,
Blanket Implementations
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more
impl<T> Pointable for T
[src]
impl<T> Pointable for T
[src]