Struct xarc::Xarc

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

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>

#[must_use]pub fn new(value: T) -> Self

Initialize the smart pointer with value.

#[must_use]pub fn null() -> Self

Initialize the smart pointer with null.

pub fn reset(&mut self)

Reset the smart pointer to null.

#[must_use]pub fn is_null(&self) -> bool

Check if the smart pointer is null.

#[must_use]pub fn maybe_deref(&self) -> Option<&T>

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

#[must_use]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 copy 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: Eq + Send> Eq for Xarc<T>

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

#[must_use]fn from(pointer: &Xarc<T>) -> Self

Performs the conversion.

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, 

Feeds a slice of this type into the given Hasher.

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

#[must_use]fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

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

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