Struct Rc

pub struct Rc<C, V, S>
where
    C: Counter,
{ /* private fields */ }

Reference counted thin pointer, that can hold one sized value and one (dynamically sized) slice

Implementations

impl<C, V> Rc<C, V, ()>

where C: Counter,

pub fn from_value(value: V) -> Self

Creates a reference counter from a (sized) value, storing it in the value field

impl<C, S> Rc<C, (), S>

where C: Counter,

pub fn from_array_into_slice<const N: usize>(array: [S; N]) -> Self

Creates a reference counter from an array, storing it in the slice field and erasing the array length from the type

If you want to keep the const length of the array, you should use from_value instead. The memory usage of the RC allocation actually does not differ between these two.

impl<C, S> Rc<C, (), S>

where C: Counter, S: Clone,

pub fn from_slice_clone(slice: &[S]) -> Self

Creates a reference counter from a slice, cloning all elements into the slice field

If your slice contains elements that implement copy, you should use from_slice_copy instead, which can be more efficient. (Rust, specialisation when?)

impl<C, S> Rc<C, (), S>

where C: Counter, S: Copy,

pub fn from_slice_copy(slice: &[S]) -> Self

Creates a reference counter from a slice, copying all elements into the slice field

impl<C, V, S> Rc<C, V, S>

where C: Counter,

pub fn from_value_and_array_into_slice<const N: usize>( value: V, array: [S; N], ) -> Self

Creates a reference counter from a value and an array, with the array being stored in the slice field

impl<C, V, S> Rc<C, V, S>

where C: Counter, S: Clone,

pub fn from_value_and_slice_clone(value: V, slice: &[S]) -> Self

Creates a reference counter from a value and a slice, cloning all elements of the slice into the slice field

If your slice contains elements that implement copy, you should use from_value_and_slice_copy instead, which can be more efficient. (Rust, specialisation when?)

impl<C, V, S> Rc<C, V, S>

where C: Counter, S: Copy,

pub fn from_value_and_slice_copy(value: V, slice: &[S]) -> Self

Creates a reference counter from a value and a slice, copying all elements of the slice into the slice field

impl<C, V, S> Rc<C, V, S>

where C: Counter,

pub fn as_value_ref(&self) -> &V

Gets an immurable reference to the value stored in the value field

pub fn as_slice_ref(&self) -> &[S]

Gets an immurable reference to the slice stored in the slice field

pub fn strong_count(&self) -> usize

Gets the strong pointer count

pub fn weak_count(&self) -> usize

Gets the weak pointer count

pub fn downgrade(&self) -> RcWeak<C, V, S>

“Downgrades” this pointer, returning a weak pointer RcWeak to the data

Trait Implementations

impl<C, V, S> Clone for Rc<C, V, S>

where C: Counter,

fn clone(&self) -> Self

Creates a new strong pointer to the same allocation, incrementing the strong count

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

Performs copy-assignment from source.

impl<C, V, S> Drop for Rc<C, V, S>

where C: Counter,

fn drop(&mut self)

Executes the destructor for this type.

impl<C, V, S> Send for Rc<C, V, S>

where C: Counter + Send, V: Send, S: Send,

impl<C, V, S> Sync for Rc<C, V, S>

where C: Counter + Sync, V: Sync, S: Sync,