Struct radium::types::Atom

pub struct Atom<T>
where
    T: Atomic,
    T::Atom: Radium<Item = T>,
{ /* private fields */ }

Atomic Primitives

This family takes a Rust primitive (bool, integer, or pointer) as a type parameter and acts as the corresponding AtomicT type. Attempting to construct an Atom<T> on a target that has no AtomicT will cause a compilation failure stating that T does not implement the Atomic trait. The Isotope<T> sibling type will never fail to compile, but in exchange does not guarantee atomic behavior.

This type implements the Radium API, as well as the Debug, Default, and From<T> traits that the standard library atomics implement. It has no other API surface.

Trait Implementations

impl<T> Debug for Atom<T>

where T: Atomic + Debug, T::Atom: Radium<Item = T> + Debug,

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for Atom<T>

where T: Atomic + Default, T::Atom: Radium<Item = T> + Default,

fn default() -> Self

Returns the “default value” for a type.

impl<T> From<T> for Atom<T>

where T: Atomic, T::Atom: Radium<Item = T> + From<T>,

fn from(val: T) -> Self

Converts to this type from the input type.

impl<T> Radium for Atom<T>

where T: Atomic + PartialEq, T::Atom: Radium<Item = T>,

type Item = T

The primitive type that this implementor makes shared-mutable.

fn new(value: T) -> Self

Creates a new value of this type.

fn get_mut(&mut self) -> &mut T

Returns a mutable reference to the underlying value.

fn into_inner(self) -> T

Consumes the wrapper and returns the contained value.

fn load(&self, order: Ordering) -> T

Loads a value from this object.

fn store(&self, value: T, order: Ordering)

Stores a value into this object.

fn swap(&self, value: T, order: Ordering) -> T

Swaps a new value with the value stored in this object.

fn compare_and_swap(&self, current: T, new: T, order: Ordering) -> T

👎Deprecated: Use compare_exchange or compare_exchange_weak instead

Stores a new value into this object if (and only if) the value currently stored in it is the same as the current argument.

fn compare_exchange( &self, current: T, new: T, success: Ordering, failure: Ordering ) -> Result<T, T>

Stores a new value into this object if (and only if) the value currently stored in it is the same as the current argument.

fn compare_exchange_weak( &self, current: T, new: T, success: Ordering, failure: Ordering ) -> Result<T, T>

Stores a new value into this object if (and only if) the value currently stored in it is the same as the current argument.

fn fetch_and(&self, value: T, order: Ordering) -> T

where T: BitOps,

Performs a bit-wise AND on the currently-stored value and the argument. The result is stored into this object, and the previous value is returned.

fn fetch_nand(&self, value: T, order: Ordering) -> T

where T: BitOps,

Performs a bit-wise NAND on the currently-stored value and the argument. The result is stored into this object, and the previous value is returned.

fn fetch_or(&self, value: T, order: Ordering) -> T

where T: BitOps,

Performs a bit-wise OR on the currently-stored value and the argument. The result is stored into this object, and the previous value is returned.

fn fetch_xor(&self, value: T, order: Ordering) -> T

where T: BitOps,

Performs a bit-wise XOR on the currently-stored value and the argument. The result is stored into this object, and the previous value is returned.

fn fetch_add(&self, value: T, order: Ordering) -> T

where T: NumericOps,

Adds the argument into the currently-stored value, wrapping on overflow. The result is stored into this object, and the previous value is returned.

fn fetch_sub(&self, value: T, order: Ordering) -> T

where T: NumericOps,

Subtracts the argument from the currently-stored value, wrapping on overflow. The result is stored into this object, and the previous value is returned.

fn fetch_max(&self, value: T, order: Ordering) -> T

where T: NumericOps,

Finds the maximum of the currently-stored value and the argument. The result is stored into this object, and the previous value is returned.

fn fetch_min(&self, value: T, order: Ordering) -> T

where T: NumericOps,

Finds the minimum of the currently-stored value and the argument. The result is stored into this object, and the previous value is returned.

fn fetch_update<F>( &self, set_order: Ordering, fetch_order: Ordering, func: F ) -> Result<T, T>

where F: FnMut(T) -> Option<T>,

Fetches the value, and applies a function to it that may produce a new value.

fn fence(order: Ordering)

If the implementor is atomic, this calls atomic::fence with the given Ordering; otherwise, it does nothing.