Struct msp430_atomic::AtomicIsize
source · #[repr(C, align(8))]pub struct AtomicIsize { /* private fields */ }
Expand description
An integer type which can be safely shared between threads.
This type has the same in-memory representation as the underlying integer type.
Implementations§
source§impl AtomicIsize
impl AtomicIsize
sourcepub const fn new(v: isize) -> Self
pub const fn new(v: isize) -> Self
Creates a new atomic integer.
Examples
use msp430_atomic::AtomicIsize;
let atomic_forty_two = AtomicIsize::new(42);
sourcepub fn get_mut(&mut self) -> &mut isize
pub fn get_mut(&mut self) -> &mut isize
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);
sourcepub fn into_inner(self) -> isize
pub fn into_inner(self) -> isize
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);
sourcepub fn load(&self) -> isize
pub fn load(&self) -> isize
Loads a value from the atomic integer.
Examples
use msp430_atomic::AtomicIsize;
let some_isize = AtomicIsize::new(5);
assert_eq!(some_isize.load(), 5);
sourcepub fn store(&self, val: isize)
pub fn store(&self, val: isize)
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);
sourcepub fn add(&self, val: isize)
pub fn add(&self, val: isize)
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);
sourcepub fn sub(&self, val: isize)
pub fn sub(&self, val: isize)
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);
sourcepub fn and(&self, val: isize)
pub fn and(&self, val: isize)
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);
sourcepub fn or(&self, val: isize)
pub fn or(&self, val: isize)
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);
sourcepub fn xor(&self, val: isize)
pub fn xor(&self, val: isize)
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);