Struct AtomicArc 

pub struct AtomicArc<T: 'static> { /* private fields */ }

An Arc with an atomically updatable pointer.

Usage notes:

• An AtomicArc can intrinsically store None (a hypothetical Option<AtomicArc<T>> would no longer be atomic).
• An AtomicArc contributes to the strong count of the pointed-to allocation, if any. However, it does not implement Deref, so methods like load must be used to obtain a Guard through which the data can be accessed.
• T must be Sized. This may be relaxed in the future.
• When an AtomicArc is updated or dropped, the strong count of the previously pointed-to object may not be immediately decremented. Thus:
  • T must be 'static to support delayed deallocations.
  • The value returned by ref_count may be an overestimate.

Examples

use aarc::{Arc, AtomicArc, Guard};

// ref count: 1
let x = Arc::new(53);
assert_eq!(Arc::ref_count(&x), 1);

// ref count: 2
let atomic = AtomicArc::new(0);
atomic.store(Some(&x));
assert_eq!(Arc::ref_count(&x), 2);

// guard doesn't affect the ref count
let guard = atomic.load().unwrap();
assert_eq!(Arc::ref_count(&x), 2);

// both the `Arc` and the `Guard` point to the same block
assert_eq!(*guard, 53);
assert_eq!(*guard, *x);

Implementations

impl<T: 'static> AtomicArc<T>

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

Similar to Arc::new, but None is a valid input, in which case the AtomicArc will store a null pointer.

To create an AtomicArc from an existing Arc, use from.

pub fn load(&self) -> Option<Guard<'static, T>>

Loads a Guard, which allows the pointed-to value to be accessed. None indicates that the inner atomic pointer is null.

pub fn swap<N: Into<NonNull<T>>>(&self, new: Option<N>) -> Option<Arc<T>>

Stores new’s pointer (or None) into self and returns the previously-stored Arc.

pub fn store<N: Into<NonNull<T>>>(&self, new: Option<N>)

Stores new’s pointer (or None) into self. Equivalent to swap, but discards the result.

Trait Implementations

impl<T: 'static> Clone for AtomicArc<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: 'static> CompareExchange<T, &Arc<T>> for AtomicArc<T>

fn compare_exchange<C: Into<NonNull<T>>>( &self, current: Option<C>, new: Option<&Arc<T>>, ) -> Result<(), Option<Guard<'static, T>>>

impl<T: 'static> CompareExchange<T, &Guard<'static, T>> for AtomicArc<T>

fn compare_exchange<C: Into<NonNull<T>>>( &self, current: Option<C>, new: Option<&Guard<'static, T>>, ) -> Result<(), Option<Guard<'static, T>>>

impl<T: Default + 'static> Default for AtomicArc<T>

fn default() -> AtomicArc<T>

Returns the “default value” for a type.

impl<T: 'static> Drop for AtomicArc<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: 'static, P: Into<NonNull<T>>> From<P> for AtomicArc<T>

fn from(value: P) -> Self

Converts to this type from the input type.

impl<T: 'static + Send + Sync> Send for AtomicArc<T>

impl<T: 'static + Send + Sync> Sync for AtomicArc<T>