Struct voluntary_servitude::atomics::FillOnceAtomicArc

pub struct FillOnceAtomicArc<T>(_);

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

Methods

impl<T> FillOnceAtomicArc<T>

pub fn new<V>(data: V) -> Self where
    V: Into<Option<Arc<T>>>, 

Creates new FillOnceAtomicArc

use std::sync::{Arc, atomic::Ordering};
let empty: FillOnceAtomicArc<()> = FillOnceAtomicArc::new(None);
assert_eq!(empty.get_ref(Ordering::Relaxed), None);

let filled = FillOnceAtomicArc::new(Arc::new(10));
assert_eq!(filled.get_ref(Ordering::Relaxed), Some(&10));

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

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

This operation is implemented as a single atomic compare_and_swap.

use std::sync::atomic::Ordering;
let option = FillOnceAtomicArc::default();
let old = option.try_store(5, Ordering::Relaxed);
assert!(old.is_ok());
assert_eq!(option.get_ref(Ordering::Relaxed), Some(&5));

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

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

Atomically retrieves a cloned Option<Arc<T>>

use std::sync::atomic::Ordering;
let empty: FillOnceAtomicArc<()> = FillOnceAtomicArc::new(None);
assert_eq!(empty.load(Ordering::Relaxed), None);

let filled = FillOnceAtomicArc::from(10);
assert_eq!(filled.load(Ordering::Relaxed).map(|a| *a), Some(10));

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

Atomically extracts a reference to the element stored

use std::sync::atomic::Ordering;
let empty: FillOnceAtomicArc<()> = FillOnceAtomicArc::new(None);
assert_eq!(empty.get_ref(Ordering::Relaxed), None);

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

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

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

use std::{sync::Arc, sync::atomic::Ordering, ptr::null_mut};
let empty = unsafe { FillOnceAtomicArc::<()>::from_raw(null_mut()) };
assert_eq!(empty.get_ref(Ordering::Relaxed), None);

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

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

Safety

To deref it you must ensure that it's not null, the FillOnceAtomicArc wasn't dropped

Returns null if FillOnceAtomicArc is empty (was not initialized)

use std::{sync::atomic::Ordering, ptr::null_mut, ops::Deref};
let empty: FillOnceAtomicArc<()> = FillOnceAtomicArc::new(None);
assert_eq!(empty.get_raw(Ordering::Relaxed), null_mut());

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

Trait Implementations

impl<T> From<T> for FillOnceAtomicArc<T>

fn from(value: T) -> Self

Performs the conversion.

impl<T> From<Arc<T>> for FillOnceAtomicArc<T>

fn from(into_ptr: Arc<T>) -> Self

Performs the conversion.

impl<T> From<Option<Arc<T>>> for FillOnceAtomicArc<T>

fn from(arc: Option<Arc<T>>) -> Self

Performs the conversion.

impl<T> Default for FillOnceAtomicArc<T>

fn default() -> Self

Returns the "default value" for a type.

impl<T: Debug> Debug for FillOnceAtomicArc<T>

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

Formats the value using the given formatter.

impl<T> Pointer for FillOnceAtomicArc<T>

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

Formats the value using the given formatter.