Struct OffsetArc 

pub struct OffsetArc<T> { /* private fields */ }

An Arc, except it holds a pointer to the T instead of to the entire ArcInner.

An OffsetArc<T> has the same layout and ABI as a non-null const T* in C, and may be used in FFI function signatures.

 Arc<T>    OffsetArc<T>
  |          |
  v          v
 ---------------------
| RefCount | T (data) | [ArcInner<T>]
 ---------------------

This means that this is a direct pointer to its contained data (and can be read from by both C++ and Rust), but we can also convert it to a “regular” Arc<T> by removing the offset.

This is very useful if you have an Arc-containing struct shared between Rust and C++, and wish for C++ to be able to read the data behind the Arc without incurring an FFI call overhead.

Implementations

impl<T> OffsetArc<T>

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 make_mut(&mut self) -> &mut T

where T: Clone,

If uniquely owned, provide a mutable reference Else create a copy, and mutate that

This is functionally the same thing as Arc::make_mut

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

Clone it as an Arc

pub fn borrow_arc(&self) -> ArcBorrow<'_, T>

Produce a pointer to the data that can be converted back to an Arc

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

The reference count of this 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.

Trait Implementations

impl<T> Clone for OffsetArc<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> Debug for OffsetArc<T>

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

Formats the value using the given formatter.

impl<T> Deref for OffsetArc<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> Drop for OffsetArc<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: PartialEq> PartialEq for OffsetArc<T>

fn eq(&self, other: &OffsetArc<T>) -> bool

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

fn ne(&self, other: &OffsetArc<T>) -> bool

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

impl<T: Eq> Eq for OffsetArc<T>

impl<T: Sync + Send> Send for OffsetArc<T>

impl<T: Sync + Send> Sync for OffsetArc<T>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes