[−][src]Trait radium::Radium

pub trait Radium {
    type Item;
    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;
}

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.

Associated Types

`type Item`[src]

Loading content...

Required methods

`fn new(value: Self::Item) -> Self`[src]

Creates a new value of this type.

`fn fence(order: Ordering)`[src]

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

`fn get_mut(&mut self) -> &mut Self::Item`[src]

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.

`fn into_inner(self) -> Self::Item`[src]

Consumes the wrapper and returns the contained value.

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

`fn load(&self, order: Ordering) -> Self::Item`[src]

Load a value from this object.

Ordering values are ignored by non-atomic types.