Struct voluntary_servitude::FillOnceAtomicArc

source ·

pub struct FillOnceAtomicArc<T>(_);

Expand description

Atomic abstractions of a Option<Arc<T>> that can provide access to a cloned Option<Arc<T>> and a Option<&T>

Implementations

source

impl<T> FillOnceAtomicArc<T>

source

pub fn new(data: Option<Arc<T>>) -> Self

Creates new FillOnceAtomicArc

let empty = FillOnceAtomicArc::<()>::default();
assert_eq!(empty.get_ref(Ordering::SeqCst), None);

let filled = FillOnceAtomicArc::from(10);
assert_eq!(filled.get_ref(Ordering::SeqCst), Some(&10));

source

pub fn try_store(&self, data: Arc<T>, order: Ordering) -> Result<(), NotEmpty>

Stores new Arc<T> if FillOnceAtomicArc currently contains a None

This operation is implemented as a single atomic compare_and_swap.

let option = FillOnceAtomicArc::default();
let old = option.try_store(5.into(), Ordering::SeqCst);
assert!(old.is_ok());
assert_eq!(option.get_ref(Ordering::SeqCst), Some(&5));

let failed_to_store = option.try_store(10.into(), Ordering::SeqCst);
assert!(failed_to_store.is_err());
assert_eq!(option.get_ref(Ordering::SeqCst), Some(&5));

source

pub fn load(&self, order: Ordering) -> Option<Arc<T>>

Atomically retrieves a cloned Option<Arc<T>>

let empty = FillOnceAtomicArc::<()>::new(None);
assert_eq!(empty.get_ref(Ordering::SeqCst), None);

let filled = FillOnceAtomicArc::from(10);
assert_eq!(filled.get_ref(Ordering::SeqCst), Some(&10));

source

pub fn get_ref(&self, order: Ordering) -> Option<&T>

Atomically extracts a reference to the element stored

let empty = FillOnceAtomicArc::<()>::new(None);
assert_eq!(empty.get_ref(Ordering::SeqCst), None);

let filled = FillOnceAtomicArc::from(10);
assert_eq!(filled.get_ref(Ordering::SeqCst), Some(&10));

source

pub fn into_inner(self) -> Option<Arc<T>>

Converts itself into a Option<Arc<T>>

let ten = FillOnceAtomicArc::from(10);
assert_eq!(ten.into_inner().map(|a| *a), Some(10));

source

pub unsafe fn from_raw(ptr: *mut Arc<T>) -> Self

Creates new FillOnceAtomicArc based on a raw pointer

Safety

Unsafe because it uses a raw pointer, so it can’t be sure of its origin (and ownership)

You must own the pointer to call this

let empty = unsafe { FillOnceAtomicArc::<()>::from_raw(null_mut()) };
assert_eq!(empty.get_ref(Ordering::SeqCst), None);

let ptr = Box::into_raw(Box::new(Arc::new(10)));
let filled = unsafe { FillOnceAtomicArc::from_raw(ptr) };
assert_eq!(filled.get_ref(Ordering::SeqCst), Some(&10));

source

pub fn get_raw(&self, order: Ordering) -> *mut Arc<T>

Atomically extracts the stored pointer

If pointer returned is not null it’s safe to deref as long as you don’t drop the FillOnceAtomicArc or call dangle in it

Safety

To deref it you must ensure that it’s not null, the FillOnceAtomicArc wasn’t dropped and dangle was not called

Returns null if FillOnceAtomicArc is empty (was not initialized or unsafely emptied with dangle and dropped)

let empty = FillOnceAtomicArc::<()>::new(None);
assert_eq!(empty.get_raw(Ordering::SeqCst), null_mut());

let filled = FillOnceAtomicArc::from(10);
assert_eq!(unsafe { (&*filled.get_raw(Ordering::SeqCst)).deref().deref() }, &10);