Trait radium::Radium

source ·

pub trait Radium {
    type Item;

Show 17 methods    // Required methods
    fn new(value: Self::Item) -> Self;
    fn fence(order: Ordering);
    fn get_mut(&mut self) -> &mut Self::Item;
    fn into_inner(self) -> Self::Item;
    fn load(&self, order: Ordering) -> Self::Item;
    fn store(&self, value: Self::Item, order: Ordering);
    fn swap(&self, value: Self::Item, order: Ordering) -> Self::Item;
    fn compare_and_swap(
        &self,
        current: Self::Item,
        new: Self::Item,
        order: Ordering
    ) -> Self::Item;
    fn compare_exchange(
        &self,
        current: Self::Item,
        new: Self::Item,
        success: Ordering,
        failure: Ordering
    ) -> Result<Self::Item, Self::Item>;
    fn compare_exchange_weak(
        &self,
        current: Self::Item,
        new: Self::Item,
        success: Ordering,
        failure: Ordering
    ) -> Result<Self::Item, Self::Item>;
    fn fetch_and(&self, value: Self::Item, order: Ordering) -> Self::Item
       where Self::Item: BitOps;
    fn fetch_nand(&self, value: Self::Item, order: Ordering) -> Self::Item
       where Self::Item: BitOps;
    fn fetch_or(&self, value: Self::Item, order: Ordering) -> Self::Item
       where Self::Item: BitOps;
    fn fetch_xor(&self, value: Self::Item, order: Ordering) -> Self::Item
       where Self::Item: BitOps;
    fn fetch_add(&self, value: Self::Item, order: Ordering) -> Self::Item
       where Self::Item: NumericOps;
    fn fetch_sub(&self, value: Self::Item, order: Ordering) -> Self::Item
       where Self::Item: NumericOps;
    fn fetch_update<F>(
        &self,
        set_order: Ordering,
        fetch_order: Ordering,
        f: F
    ) -> Result<Self::Item, Self::Item>
       where F: FnMut(Self::Item) -> Option<Self::Item>;
}

Expand description

A maybe-atomic shared mutable fundamental type T.

This trait is implemented by both the atomic wrapper type for T, and by Cell<T>, providing a consistent interface for interacting with the two types.

This trait provides methods predicated on marker traits for the underlying fundamental. Only types which can be viewed as sequences of bits may use the functions for bit-wise arithmetic, and only types which can be used as integers may use the functions for numeric arithmetic. Use of these methods on insufficient underlying types (for example, Radium::fetch_and on an atomic or cell-wrapped pointer) will cause a compiler error.

Required Associated Types§

source

type Item

Required Methods§

source

fn new(value: Self::Item) -> Self

Creates a new value of this type.

source

fn fence(order: Ordering)

If the underlying value is atomic, calls fence with the given Ordering. Otherwise, does nothing.

source

fn get_mut(&mut self) -> &mut Self::Item

Returns a mutable reference to the underlying value.

This is safe because the mutable reference to self guarantees that no other references exist to this value.

source

fn into_inner(self) -> Self::Item

Consumes the wrapper and returns the contained value.

This is safe as passing by value ensures no other references exist.

source

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

Load a value from this object.

Ordering values are ignored by non-atomic types.