Struct msp430_atomic::AtomicUsize

#[repr(C, align(8))]
pub struct AtomicUsize { /* private fields */ }

An integer type which can be safely shared between threads.

This type has the same in-memory representation as the underlying integer type.

Implementations

impl AtomicUsize

pub const fn new(v: usize) -> Self

Creates a new atomic integer.

Examples

use msp430_atomic::AtomicIsize;

let atomic_forty_two  = AtomicIsize::new(42);

pub fn get_mut(&mut self) -> &mut usize

Returns a mutable reference to the underlying integer.

This is safe because the mutable reference guarantees that no other threads are concurrently accessing the atomic data.

Examples

use msp430_atomic::AtomicIsize;

let mut some_isize = AtomicIsize::new(10);
assert_eq!(*some_isize.get_mut(), 10);
*some_isize.get_mut() = 5;
assert_eq!(some_isize.load(), 5);

pub fn into_inner(self) -> usize

Consumes the atomic and returns the contained value.

This is safe because passing self by value guarantees that no other threads are concurrently accessing the atomic data.

Examples

use msp430_atomic::AtomicIsize;

let some_isize = AtomicIsize::new(5);
assert_eq!(some_isize.into_inner(), 5);

pub fn load(&self) -> usize

Loads a value from the atomic integer.

Examples

use msp430_atomic::AtomicIsize;

let some_isize = AtomicIsize::new(5);

assert_eq!(some_isize.load(), 5);

pub fn store(&self, val: usize)

Stores a value into the atomic integer.

Examples

use msp430_atomic::AtomicIsize;

let some_isize = AtomicIsize::new(5);

some_isize.store(10);
assert_eq!(some_isize.load(), 10);

pub fn add(&self, val: usize)

Adds to the current value, returning the previous value.

This operation wraps around on overflow.

Examples

use msp430_atomic::AtomicIsize;

let foo = AtomicIsize::new(0);
foo.add(10);
assert_eq!(foo.load(), 10);

pub fn sub(&self, val: usize)

Subtracts from the current value, returning the previous value.

This operation wraps around on overflow.

Examples

use msp430_atomic::AtomicIsize;

let foo = AtomicIsize::new(0);
foo.sub(10);
assert_eq!(foo.load(), -10);

pub fn and(&self, val: usize)

Bitwise “and” with the current value.

Performs a bitwise “and” operation on the current value and the argument val, and sets the new value to the result.

Examples

use msp430_atomic::AtomicIsize;

let foo = AtomicIsize::new(0b101101);
foo.and(0b110011);
assert_eq!(foo.load(), 0b100001);

pub fn or(&self, val: usize)

Bitwise “or” with the current value.

Performs a bitwise “or” operation on the current value and the argument val, and sets the new value to the result.

Examples

use msp430_atomic::AtomicIsize;

let foo = AtomicIsize::new(0b101101);
foo.or(0b110011);
assert_eq!(foo.load(), 0b111111);

pub fn xor(&self, val: usize)

Bitwise “xor” with the current value.

Performs a bitwise “xor” operation on the current value and the argument val, and sets the new value to the result.

Examples

use msp430_atomic::AtomicIsize;

let foo = AtomicIsize::new(0b101101);
foo.xor(0b110011);
assert_eq!(foo.load(), 0b011110);

Trait Implementations

impl Debug for AtomicUsize

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

Formats the value using the given formatter.

impl Default for AtomicUsize

fn default() -> Self

Returns the “default value” for a type.

impl Sync for AtomicUsize