Struct radium::types::Radon

pub struct Radon<T>
where
    T: Nuclear,
    Cell<T>: Radium<Item = T>,
{ /* private fields */ }

Non-Atomic Primitives

This family takes a Rust primitive (bool, integer, or pointer) as a type parameter and wraps it in a Cell. Like Atom<T> and Isotope<T>, it implements only the Radium API (and Debug, Default, and From<T>), and as such is suitable for cases where a crate wants to turn off atomic usage entirely, while guaranteeing that swapping out types will not cause a compilation failure.

Examples

Consider a crate with an "atomic" feature. It might decide to attempt atomic behavior when this flag is on, and unconditionally deny it when the flag is off:

#[cfg(feature = "atomic")]
pub type MyAtom<T> = radium::types::Isotope<T>;

#[cfg(not(feature = "atomic"))]
pub type MyAtom<T> = radium::types::Radon<T>;

Behind the Name

Radium decays into radon, and the Radon type is a “decayed” Radium implementor. Radon gas is also poisonous, and Radon poisons your codebase against multithreading.

Trait Implementations

impl<T> Debug for Radon<T>

where T: Nuclear + Debug, Cell<T>: Radium<Item = T> + Debug,

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

Formats the value using the given formatter.

impl<T> Default for Radon<T>

where T: Nuclear + Default, Cell<T>: Radium<Item = T> + Default,

fn default() -> Self

Returns the “default value” for a type.

impl<T> From<T> for Radon<T>

where T: Nuclear, Cell<T>: Radium<Item = T> + From<T>,

fn from(val: T) -> Self

Converts to this type from the input type.

impl<T> Radium for Radon<T>

where T: Nuclear + PartialEq, Cell<T>: 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(_: Ordering)

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