[−][src]Trait radium::RadiumU32

pub trait RadiumU32 {
    fn new(v: u32) -> Self;

    fn fence(order: Ordering);

    fn get_mut(&mut self) -> &mut u32;

    fn into_inner(self) -> u32;

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

    fn store(&self, val: u32, order: Ordering);

    fn swap(&self, val: u32, order: Ordering) -> u32;

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

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

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

    fn fetch_and(&self, val: u32, order: Ordering) -> u32;

    fn fetch_nand(&self, val: u32, order: Ordering) -> u32;

    fn fetch_or(&self, val: u32, order: Ordering) -> u32;

    fn fetch_xor(&self, val: u32, order: Ordering) -> u32;

    fn fetch_add(&self, val: u32, order: Ordering) -> u32;

    fn fetch_sub(&self, val: u32, order: Ordering) -> u32;
}

A maybe-atomic shared mutable u32.

This trait is implemented by both AtomicU32 and Cell<u32>, providing a consistent interface for interacting with the two types.

Required methods

fn new(v: u32) -> Self

Creates a new value of this type.

fn fence(order: Ordering)

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

See also: fence

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

Returns a mutable reference to the underlying value.

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

fn into_inner(self) -> u32

Consumes and returns the contained value.

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

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

Load a value from this object.

Ordering arguments are ignored by non-atomic types.

See also: AtomicU32::load

fn store(&self, val: u32, order: Ordering)

Store a value in this object.

Ordering arguments are ignored by non-atomic types.

See also: AtomicU32::store

fn swap(&self, val: u32, order: Ordering) -> u32

Swap with the value stored in this object.

Ordering arguments are ignored by non-atomic types.

See also: AtomicU32::swap

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

Stores a value into this object if the current value is the same as the current value.

The return value is always the previous value. If it is equal to current, then the value was updated.

Ordering arguments are ignored by non-atomic types.

See also: AtomicU32::compare_and_swap

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

Stores a value into this object if the current value is the same as the current value.

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.

Ordering arguments are ignored by non-atomic types.

See also: AtomicU32::compare_exchange

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

Stores a value into this object if the current value is the same as the current value.

Unlike compare_exchange, this function is allowed to spuriously fail even when the comparison succeeds, which can result in more efficient code on some platforms. The return value is a result indicating whether the new value was written and containing the previous value.

Ordering arguments are ignored by non-atomic types.

See also: AtomicU32::compare_exchange_weak

fn fetch_and(&self, val: u32, order: Ordering) -> u32

Performs a bitwise "and" on the current value and the argument val, snd sets the new value to the result.

Returns the previous value.

Ordering arguments are ignored by non-atomic types.

See also: AtomicU32::fetch_and

fn fetch_nand(&self, val: u32, order: Ordering) -> u32

Performs a bitwise "nand" on the current value and the argument val, snd sets the new value to the result.

Returns the previous value.

Ordering arguments are ignored by non-atomic types.

See also: AtomicU32::fetch_nand

fn fetch_or(&self, val: u32, order: Ordering) -> u32

Performs a bitwise "or" on the current value and the argument val, snd sets the new value to the result.

Returns the previous value.

Ordering arguments are ignored by non-atomic types.

See also: AtomicU32::fetch_or

fn fetch_xor(&self, val: u32, order: Ordering) -> u32

Performs a bitwise "xor" on the current value and the argument val, snd sets the new value to the result.

Returns the previous value.

Ordering arguments are ignored by non-atomic types.

See also: AtomicU32::fetch_xor

fn fetch_add(&self, val: u32, order: Ordering) -> u32

Increments the current value by val, wrapping on overflow.

Returns the previous value.

Ordering arguments are ignored by non-atomic types.

See also: AtomicU32::fetch_add

fn fetch_sub(&self, val: u32, order: Ordering) -> u32

Decrements the current value by val, wrapping on overflow.

Returns the previous value.

Ordering arguments are ignored by non-atomic types.

See also: AtomicU32::fetch_sub

Loading content...

Implementations on Foreign Types

impl RadiumU32 for AtomicU32[src]

impl RadiumU32 for Cell<u32>[src]

Loading content...

Implementors

Loading content...