Struct xarc::AtomicXarc

pub struct AtomicXarc<T: Send> { /* fields omitted */ }

AtomicXarc provides atomic storage for Xarc atomically refcounted smart pointers.

Examples

Here is some typical usage of AtomicXarc.

use core::sync::atomic::Ordering;
use xarc::{AtomicXarc, Xarc};
 
let atomic = AtomicXarc::new(42);
let same = atomic.load(Ordering::Acquire);
let different = Xarc::new(42);
 
assert_eq!(*atomic.load(Ordering::Acquire).maybe_deref().unwrap(), 42);
assert!(atomic.compare_exchange(&different, &Xarc::null(), Ordering::AcqRel, Ordering::Acquire)
        .is_err());
assert_eq!(*atomic.compare_exchange(&same, &Xarc::null(), Ordering::AcqRel, Ordering::Acquire)
            .unwrap().maybe_deref().unwrap(), 42);

Implementations

impl<T: Send> AtomicXarc<T>

#[must_use]

pub fn new(value: T) -> Self

Initialize the atomic smart pointer with value.

#[must_use]

pub fn null() -> Self

Initialize the atomic smart pointer with null.

#[must_use]

pub fn compare_and_swap(
    &self,
    current: &Xarc<T>,
    new: &Xarc<T>,
    success: Ordering,
    failure: Ordering
) -> Xarc<T>

As an atomic operation, swap the contents of self with new if self == current. Returns the previous value of self. If the value does not equal current the operation failed.

pub fn compare_exchange(
    &self,
    current: &Xarc<T>,
    new: &Xarc<T>,
    success: Ordering,
    failure: Ordering
) -> Result<Xarc<T>, Xarc<T>>

As an atomic operation, swap the contents of self with new if self == current. Returns the previous value of self in a Result indicating whether the operation succeeded or failed.

pub fn compare_exchange_weak(
    &self,
    current: &Xarc<T>,
    new: &Xarc<T>,
    success: Ordering,
    failure: Ordering
) -> Result<Xarc<T>, Xarc<T>>

As an atomic operation, swap the contents of self with new if self == current but with spurious failure of the comparison allowed. Returns the previous value of self in a Result indicating whether the operation succeeded or failed. Allowing spurious failure is a performance optimization that is reasonable when no additional loops are required for correctness.

#[must_use]

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

Load the value into an Xarc. The internal atomic operation is repeated as needed until successful.

pub fn try_load(&self, order: Ordering) -> Result<Xarc<T>, ()>

Attempt to load the value into an Xarc. It can fail if, after the pointer has been loaded but before it is used, it is swapped out in another thread and destroyed.

#[must_use]

pub fn swap(&self, new: &Xarc<T>, order: Ordering) -> Xarc<T>

As an atomic operation, swap the contents of self with new. Returns the previous value of self.

Trait Implementations

impl<T: Debug + Send> Debug for AtomicXarc<T>

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

Formats the value using the given formatter.

impl<T: Send> Drop for AtomicXarc<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Send> From<&'_ Xarc<T>> for AtomicXarc<T>

#[must_use]

fn from(pointer: &Xarc<T>) -> Self

Performs the conversion.