Struct heaparray::naive_rc::generic::RcArray

#[repr(transparent)]
pub struct RcArray<A, R, E, L = ()> where
    A: LabelledArray<E, R>,
    R: RefCounter<L>,  { /* fields omitted */ }

RcArray is a generic, implementation-agnositc array. It contains logic for enforcing type safety.

The type parameters are, in order:

A: A struct that acts as a reference to an array.
R: A reference-counting structure, that wraps the label. Note that this
   *can be the label itself*. It just needs to have defined ways of incrementing
   and decrementing its reference count.
E: The elements that this array contains.
L: The label that is associated with this array.

Methods

impl<A, R, E, L> RcArray<A, R, E, L> where
    A: LabelledArray<E, R>,
    R: RefCounter<L>, 

pub fn ref_count(&self) -> usize

Returns the reference count of the data this RcArray points to.

pub fn to_owned(self) -> Result<A, Self>

Returns an owned version of this array if the caller has exclusive access, or returns back this reference otherwise.

pub fn to_mut(&mut self) -> Option<&mut A>

Returns a mutable reference to the array if the caller has exclusive access, or None otherwise.

impl<A, R, E, L> RcArray<A, R, E, L> where
    A: LabelledArray<E, R> + Clone,
    R: RefCounter<L>, 

pub fn make_owned(self) -> A

Returns an owned version of this array if the caller has exclusive access, or copies the data otherwise.

pub fn make_mut(&mut self) -> &mut A

Returns a mutable reference to the array if the caller has exclusive access, or copies the data otherwise.

Trait Implementations

impl<A, R, E, L> ArrayRef for RcArray<A, R, E, L> where
    A: LabelledArray<E, R>,
    R: RefCounter<L>, 

fn clone(ptr: &Self) -> Self

Clones the array reference. Internally just calls its .clone() method.

impl<A, R, E, L> LabelledArray<E, L> for RcArray<A, R, E, L> where
    A: LabelledArray<E, R>,
    R: RefCounter<L>, 

fn with_label<F>(label: L, len: usize, func: F) -> Self where
    F: FnMut(&mut L, usize) -> E, 

Create a new array, with values initialized using a provided function, and label initialized to a provided value.

fn get_label(&self) -> &L

Get a reference to the label.

unsafe fn get_unchecked(&self, idx: usize) -> &E

Get a reference to the element at a specified index. Implementations of this method shouldn't do any safety checks.

impl<A, R, E, L> DefaultLabelledArray<E, L> for RcArray<A, R, E, L> where
    A: DefaultLabelledArray<E, R> + LabelledArray<E, R>,
    R: RefCounter<L>,
    E: Default, 

fn with_len(label: L, len: usize) -> Self

Create a new array, initialized to default values.

impl<A, R, E> MakeArray<E> for RcArray<A, R, E, ()> where
    A: LabelledArray<E, R>,
    R: RefCounter<()>, 

fn new<F>(len: usize, func: F) -> Self where
    F: FnMut(usize) -> E, 

Create a new array, with values initialized using a provided function.

impl<A, R, E, L> SliceArray<E> for RcArray<A, R, E, L> where
    A: LabelledArray<E, R> + SliceArray<E>,
    R: RefCounter<L>, 

fn as_slice(&self) -> &[E]

Returns a reference to a slice into the elements of this array.

impl<A, R, E, L> Send for RcArray<A, R, E, L> where
    A: LabelledArray<E, R> + Send + Sync,
    R: RefCounter<L> + Send + Sync,
    E: Send + Sync,
    L: Send + Sync, 

impl<A, R, E, L> Drop for RcArray<A, R, E, L> where
    A: LabelledArray<E, R>,
    R: RefCounter<L>, 

fn drop(&mut self)

Executes the destructor for this type.

impl<'b, A, R, E, L> IntoIterator for &'b RcArray<A, R, E, L> where
    A: LabelledArray<E, R> + SliceArray<E>,
    R: RefCounter<L>, 

type Item = &'b E

The type of the elements being iterated over.

type IntoIter = Iter<'b, E>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A, R, E, L> Sync for RcArray<A, R, E, L> where
    A: LabelledArray<E, R> + Send + Sync,
    R: RefCounter<L> + Send + Sync,
    E: Send + Sync,
    L: Send + Sync, 

impl<A, R, E, L> Clone for RcArray<A, R, E, L> where
    A: LabelledArray<E, R>,
    R: RefCounter<L>, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A, R, E, L> Index<usize> for RcArray<A, R, E, L> where
    A: LabelledArray<E, R> + Index<usize, Output = E>,
    R: RefCounter<L>, 

type Output = E

The returned type after indexing.

fn index(&self, idx: usize) -> &E

Performs the indexing (container[index]) operation.

impl<A, R, E, L> Debug for RcArray<A, R, E, L> where
    A: LabelledArray<E, R> + SliceArray<E>,
    R: RefCounter<L>,
    E: Debug,
    L: Debug, 

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

Formats the value using the given formatter.

impl<A, R, E, L> Container for RcArray<A, R, E, L> where
    A: LabelledArray<E, R>,
    R: RefCounter<L>, 

fn len(&self) -> usize

Get the size of the container.

impl<A, R, E, L> CopyMap<usize, E> for RcArray<A, R, E, L> where
    A: LabelledArray<E, R>,
    R: RefCounter<L>, 

fn get(&self, key: usize) -> Option<&E>

Get a reference into this array. Returns None if:

• The index given is out-of-bounds

fn get_mut(&mut self, key: usize) -> Option<&mut E>

Get a mutable reference into this array. Returns None if:

• The array is referenced by another pointer
• The index given is out-of-bounds

fn insert(&mut self, key: usize, value: E) -> Option<E>

Insert an element into this array. Returns None if:

• The array is referenced by another pointer
• The index given is out-of-bounds
• There was nothing in the slot previously