Struct Xarc

pub struct Xarc<T: Send> { /* private fields */ }

Xarc is a derefenceable atomically refcounted smart pointer. Xarc is roughly equivalent to Arc but is compatible with AtomicXarc.

Examples

Here is some typical usage of Xarc.

use xarc::Xarc;
 
let xarc = Xarc::new(42);
let same = xarc.clone();
let different = Xarc::new(42);
 
// Null checks
assert!(!xarc.is_null());
assert_ne!(xarc, Xarc::null());
 
// Pointer comparisons
assert_eq!(xarc, same);
assert_ne!(xarc, different);
 
// Value comparisons
assert_eq!(xarc.maybe_deref().unwrap(), different.maybe_deref().unwrap());
assert_eq!(Xarc::<i64>::null().maybe_deref(), None);

When implementing a container you often need structures with an immutable part, such as a pointer to another part of the structure, and a separate value that you can take to return a value as you remove it. UnsafeCell comes to the rescue.

use core::{cell::UnsafeCell, mem};
use xarc::Xarc;
 
struct Example {
    immutable: i64,
    takeable: UnsafeCell<i64>,
}
 
let mut xarc = Xarc::new(Example {immutable: 0, takeable: UnsafeCell::new(42)});
 
let value = unsafe {
    // You had better know what you're doing at this point. 🙂
    core::mem::take(&mut *xarc.maybe_deref().unwrap().takeable.get())
};
 
assert_eq!(value, 42);

Implementations

impl<T: Send> Xarc<T>

pub fn new(value: T) -> Self

Initialize the smart pointer with value.

pub fn null() -> Self

Initialize the smart pointer with null.

pub fn reset(&mut self)

Reset the smart pointer to null.

pub fn is_null(&self) -> bool

Check if the smart pointer is null.

pub fn maybe_deref(&self) -> Option<&T>

Dereference the pointer only if it is not null. None will be returned if it is null.

pub unsafe fn unguarded_maybe_deref_mut(&mut self) -> Option<&mut T>

Dereference the pointer only if it is not null. None will be returned if it is null.

Safety

• This should be called only if you’re absolutely, 100% certain that nobody else could possibly have access to this data or if you really know what you’re doing.

Trait Implementations

impl<T: Send> Clone for Xarc<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: Debug + Send> Debug for Xarc<T>

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

Formats the value using the given formatter.

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

fn drop(&mut self)

Executes the destructor for this type.

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

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

Converts to this type from the input type.

impl<T: Send> Hash for Xarc<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Send> PartialEq for Xarc<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq + Send> Eq for Xarc<T>

impl<T: Send> Send for Xarc<T>

impl<T: Send> Sync for Xarc<T>