Struct elysees::Arc

#[repr(transparent)]pub struct Arc<T> { /* fields omitted */ }

An atomically reference counted shared pointer

See the documentation for Arc in the standard library. Unlike the standard library Arc, this Arc holds a pointer to the T instead of to the entire ArcInner. This makes the struct FFI-compatible, and allows a variety of pointer casts, e.g. &[Arc<T>] to &[&T].

 ArcHandle<T>           Arc<T>
 std::sync::Arc<T>      ArcBorrow<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 an ArcHandle<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> Arc<T>

pub fn new(data: T) -> Self

Construct an Arc<T>

pub fn with_handle<F, U>(&self, f: F) -> U where
    F: FnOnce(&ArcHandle<T>) -> U, 

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

pub fn make_mut(&mut self) -> &mut T where
    T: Clone, 

Makes a mutable reference to the Arc, cloning if necessary

This is functionally equivalent to Arc::make_mut from the standard library.

If this ArcHandle is uniquely owned, make_mut() will provide a mutable reference to the contents. If not, make_mut() will create a new ArcHandle with a copy of the contents, update this to point to it, and provide a mutable reference to its contents.

This is useful for implementing copy-on-write schemes where you wish to avoid copying things if your Arc is not shared.

pub fn clone_handle(&self) -> ArcHandle<T>

Clone this Arc as an ArcHandle

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

Produce a pointer to the data that can be converted back to an Arc<T>. This is basically an &Arc<T>, without the extra indirection. It has the benefits of an &T but also knows about the underlying refcount and can be converted into more Arc<T>s if necessary.

pub fn as_borrow<'a>(&'a self) -> &'a ArcBorrow<'a, T>

Borrow this Arc as an ArcBorrow

pub fn get_count(&self, ordering: Ordering) -> usize

Get the reference count of this Arc with a given memory ordering

Trait Implementations

impl<'a, T> AsRef<Arc<T>> for ArcBorrow<'a, T>

fn as_ref(&self) -> &Arc<T>

Performs the conversion.

impl<'a, T> AsRef<T> for Arc<T>

fn as_ref(&self) -> &T

Performs the conversion.

impl<'a, T> Borrow<Arc<T>> for ArcBorrow<'a, T>

fn borrow(&self) -> &Arc<T>

Immutably borrows from an owned value.

impl<'a, T> Borrow<T> for Arc<T>

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T> Clone for Arc<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> CloneStableDeref for Arc<T>

impl<T: Debug> Debug for Arc<T>

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

Formats the value using the given formatter.

impl<T> Deref for Arc<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<'de, T: Deserialize<'de>> Deserialize<'de> for Arc<T>

fn deserialize<D>(deserializer: D) -> Result<Arc<T>, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T> Drop for Arc<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Eq> Eq for Arc<T>

impl<T: Hash> Hash for Arc<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: PartialEq> PartialEq<Arc<T>> for Arc<T>

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

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

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

This method tests for !=.

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

impl<T: Serialize> Serialize for Arc<T>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<T> StableDeref for Arc<T>

impl<T> StructuralEq for Arc<T>

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