Struct AtomicI8 

pub struct AtomicI8 { /* 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 AtomicI8

pub const fn new(v: i8) -> 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 i8

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) -> i8

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) -> i8

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: i8)

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: i8)

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: i8)

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: i8)

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: i8)

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: i8)

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 AtomicI8

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

Formats the value using the given formatter.

impl Default for AtomicI8

fn default() -> Self

Returns the “default value” for a type.

impl Sync for AtomicI8