Struct msp430_atomic::AtomicPtr

pub struct AtomicPtr<T> { /* fields omitted */ }

A raw pointer type which can be safely shared between threads.

This type has the same in-memory representation as a *mut T.

Implementations

impl<T> AtomicPtr<T>

pub const fn new(p: *mut T) -> AtomicPtr<T>

Creates a new AtomicPtr.

Examples

use msp430_atomic::AtomicPtr;

let ptr = &mut 5;
let atomic_ptr  = AtomicPtr::new(ptr);

pub fn get_mut(&mut self) -> &mut *mut T

Returns a mutable reference to the underlying pointer.

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

Examples

use msp430_atomic::AtomicPtr;

let mut atomic_ptr = AtomicPtr::new(&mut 10);
*atomic_ptr.get_mut() = &mut 5;
assert_eq!(unsafe { *atomic_ptr.load() }, 5);

pub fn into_inner(self) -> *mut T

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::AtomicPtr;

let atomic_ptr = AtomicPtr::new(&mut 5);
assert_eq!(unsafe { *atomic_ptr.into_inner() }, 5);

pub fn load(&self) -> *mut T

Loads a value from the pointer.

Examples

use msp430_atomic::AtomicPtr;

let ptr = &mut 5;
let some_ptr  = AtomicPtr::new(ptr);

let value = some_ptr.load();

pub fn store(&self, ptr: *mut T)

Stores a value into the pointer.

Examples

use msp430_atomic::AtomicPtr;

let ptr = &mut 5;
let some_ptr  = AtomicPtr::new(ptr);

let other_ptr = &mut 10;

some_ptr.store(other_ptr);

Trait Implementations

impl<T> Debug for AtomicPtr<T>

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

Formats the value using the given formatter.

impl<T> Default for AtomicPtr<T>

fn default() -> AtomicPtr<T>

Creates a null AtomicPtr<T>.

impl<T> Send for AtomicPtr<T>

impl<T> Sync for AtomicPtr<T>