Struct ArcBorrow

pub struct ArcBorrow<'a, T: ?Sized + 'a>(/* private fields */);

A “borrowed Arc”. This is a pointer to a T that is known to have been allocated within an Arc.

This is equivalent in guarantees to &Arc<T>, however it is a bit more flexible. To obtain an &Arc<T> you must have an Arc<T> instance somewhere pinned down until we’re done with it. It’s also a direct pointer to T, so using this involves less pointer-chasing

However, C++ code may hand us refcounted things as pointers to T directly, so we have to conjure up a temporary Arc on the stack each time. The same happens for when the object is managed by a OffsetArc.

ArcBorrow lets us deal with borrows of known-refcounted objects without needing to worry about where the Arc<T> is.

Implementations

impl<'a, T> ArcBorrow<'a, T>

pub fn clone_arc(&self) -> Arc<T>

Clone this as an Arc<T>. This bumps the refcount.

pub unsafe fn from_ptr(ptr: *const T) -> Self

For constructing from a pointer known to be Arc-backed, e.g. if we obtain such a pointer over FFI

Safety

• The pointer to T must have come from a Triomphe Arc, UniqueArc, or ArcBorrow.
• The pointer to T must have full provenance over the Arc, UniqueArc, or ArcBorrow, in particular it must not have been derived from a &T reference, as references immediately loose all provenance over the adjacent reference counts. As of this writing, of the 3 types, only Trimphe’s Arc offers a direct API for obtaining such a pointer: Arc::as_ptr.

pub fn ptr_eq(this: &Self, other: &Self) -> bool

Compare two ArcBorrows via pointer equality. Will only return true if they come from the same allocation

pub fn strong_count(this: &Self) -> usize

The reference count of the underlying Arc.

The number does not include borrowed pointers, or temporary Arc pointers created with functions like ArcBorrow::with_arc.

The function is called strong_count to mirror std::sync::Arc::strong_count, however triomphe::Arc does not support weak references.

pub fn with_arc<F, U>(&self, f: F) -> U

where F: FnOnce(&Arc<T>) -> U,

Temporarily converts |self| into a bonafide Arc and exposes it to the provided callback. The refcount is not modified.

pub fn get(&self) -> &'a T

Similar to deref, but uses the lifetime |a| rather than the lifetime of self, which is incompatible with the signature of the Deref trait.

Trait Implementations

impl<'a, T> Clone for ArcBorrow<'a, T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'lt, T: 'lt, U: ?Sized + 'lt> CoerciblePtr<U> for ArcBorrow<'lt, T>

type Pointee = T

The type we point to. This influences which kinds of unsizing are possible.

type Output = ArcBorrow<'lt, U>

The output type when unsizing the pointee to U.

fn as_sized_ptr(&mut self) -> *mut T

Get the raw inner pointer.

unsafe fn replace_ptr(self, new: *mut U) -> ArcBorrow<'lt, U>

Replace the container inner pointer with an unsized version.

impl<'a, T: Debug + ?Sized + 'a> Debug for ArcBorrow<'a, T>

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

Formats the value using the given formatter.

impl<'a, T> Deref for ArcBorrow<'a, T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<'a, T: PartialEq + ?Sized + 'a> PartialEq for ArcBorrow<'a, T>

fn eq(&self, other: &ArcBorrow<'a, T>) -> 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<'a, T> Copy for ArcBorrow<'a, T>

impl<'a, T: Eq + ?Sized + 'a> Eq for ArcBorrow<'a, T>

impl<'a, T: ?Sized + Sync + Send> Send for ArcBorrow<'a, T>

impl<'a, T: ?Sized + 'a> StructuralPartialEq for ArcBorrow<'a, T>

impl<'a, T: ?Sized + Sync + Send> Sync for ArcBorrow<'a, T>