Struct heaparray::naive_rc::generic::RcArray

#[repr(C)]
pub struct RcArray<'a, A, R, E, L = ()> where
    A: 'a + LabelledArray<'a, E, R> + BaseArrayRef + UnsafeArrayRef,
    R: 'a + RefCounter<L>,
    L: 'a,
    E: 'a,  { /* fields omitted */ }

RcArray is a generic, implementation-agnositc array. It uses traits to handle literally everything. Implementing your own version is not recommended.

Methods

impl<'a, A, R, E, L> RcArray<'a, A, R, E, L> where
    A: 'a + LabelledArray<'a, E, R> + BaseArrayRef + UnsafeArrayRef,
    R: 'a + RefCounter<L>,
    L: 'a,
    E: 'a, 

pub fn ref_count(&self) -> usize

Trait Implementations

impl<'a, A, R, E, L> BaseArrayRef for RcArray<'a, A, R, E, L> where
    A: 'a + LabelledArray<'a, E, R> + BaseArrayRef + UnsafeArrayRef,
    R: 'a + RefCounter<L>,
    L: 'a,
    E: 'a, 

fn is_null(&self) -> bool

Returns whether the array pointer that this contains is null.

impl<'a, A, R, E, L> ArrayRef for RcArray<'a, A, R, E, L> where
    A: 'a + LabelledArray<'a, E, R> + BaseArrayRef + UnsafeArrayRef,
    R: 'a + RefCounter<L>,
    L: 'a,
    E: 'a, 

fn to_null(&mut self)

Set this pointer to null.

fn null_ref() -> Self

Get a null reference of this pointer type.

fn clone(ptr: &Self) -> Self

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

impl<'a, A, R, E, L> AtomicArrayRef for RcArray<'a, A, R, E, L> where
    A: 'a + LabelledArray<'a, E, R> + BaseArrayRef + UnsafeArrayRef + AtomicArrayRef,
    R: 'a + RefCounter<L>,
    L: 'a,
    E: 'a, 

fn compare_and_swap(&self, current: Self, new: Self, order: Ordering) -> Self

fn compare_exchange(
    &self,
    current: Self,
    new: Self,
    success: Ordering,
    failure: Ordering
) -> Result<Self, Self>

fn compare_exchange_weak(
    &self,
    current: Self,
    new: Self,
    success: Ordering,
    failure: Ordering
) -> Result<Self, Self>

fn load(&self, order: Ordering) -> Self

fn store(&self, ptr: Self, order: Ordering)

fn swap(&self, ptr: Self, order: Ordering) -> Self

impl<'a, A, R, E, L> LabelledArray<'a, E, L> for RcArray<'a, A, R, E, L> where
    A: 'a + LabelledArray<'a, E, R> + BaseArrayRef + UnsafeArrayRef,
    R: 'a + RefCounter<L>,
    L: 'a,
    E: 'a, 

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.

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

Create a new array, without initializing the values in it.

fn get_label(&self) -> &L

Get immutable access to the label.

fn get_label_mut(&mut self) -> &mut L

Get mutable reference to the label.

unsafe fn get_label_unsafe(&self) -> &mut L

Get a mutable reference to the label. Implementations of this method shouldn't do any safety checks.

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

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

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

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

Create a new array, initialized to default values.

impl<'a, A, R, E> MakeArray<'a, E> for RcArray<'a, A, R, E, ()> where
    A: 'a + LabelledArray<'a, E, R> + BaseArrayRef + UnsafeArrayRef,
    R: 'a + RefCounter<()>,
    E: 'a, 

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, A, R, E, L> Sync for RcArray<'a, A, R, E, L> where
    A: 'a + LabelledArray<'a, E, R> + BaseArrayRef + UnsafeArrayRef,
    R: 'a + RefCounter<L> + Send + Sync,
    L: 'a + Send + Sync,
    E: 'a + Send + Sync, 

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

impl<'a, A, R, E, L> Clone for RcArray<'a, A, R, E, L> where
    A: 'a + LabelledArray<'a, E, R> + BaseArrayRef + UnsafeArrayRef,
    R: 'a + RefCounter<L>,
    L: 'a,
    E: 'a, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, A, R, E, L> Drop for RcArray<'a, A, R, E, L> where
    A: 'a + LabelledArray<'a, E, R> + BaseArrayRef + UnsafeArrayRef,
    R: 'a + RefCounter<L>,
    L: 'a,
    E: 'a, 

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, A, R, E, L> Index<usize> for RcArray<'a, A, R, E, L> where
    A: 'a + LabelledArray<'a, E, R> + BaseArrayRef + UnsafeArrayRef,
    R: 'a + RefCounter<L>,
    L: 'a,
    E: 'a, 

type Output = E

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a, A, R, E, L> IndexMut<usize> for RcArray<'a, A, R, E, L> where
    A: 'a + LabelledArray<'a, E, R> + BaseArrayRef + UnsafeArrayRef,
    R: 'a + RefCounter<L>,
    L: 'a,
    E: 'a, 

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

Performs the mutable indexing (container[index]) operation.

impl<'a, A, R, E, L> Container<(usize, E)> for RcArray<'a, A, R, E, L> where
    A: 'a + LabelledArray<'a, E, R> + BaseArrayRef + UnsafeArrayRef,
    R: 'a + RefCounter<L>,
    L: 'a,
    E: 'a, 

fn add(&mut self, elem: (usize, E))

Add an element to the container.

fn len(&self) -> usize

Get the size of the container.

impl<'a, A, R, E, L> CopyMap<'a, usize, E, (usize, E), &'a E, &'a mut E> for RcArray<'a, A, R, E, L> where
    A: 'a + LabelledArray<'a, E, R> + BaseArrayRef + UnsafeArrayRef,
    R: 'a + RefCounter<L>,
    L: 'a,
    E: 'a, 

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

Get a value from this Map. Takes a key by reference and returns a reference to the corresponding data, or None if none exists.

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

Returns a mutable reference to an object stored in this container based on the key given, or None if the key does not exist.

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

Adds a new item into this container with the associated key, and returns the previous value associated with that key, if it existed.

impl<'a, A, R, E, L> Array<'a, E, &'a E, &'a mut E> for RcArray<'a, A, R, E, L> where
    A: 'a + LabelledArray<'a, E, R> + BaseArrayRef + UnsafeArrayRef,
    R: 'a + RefCounter<L>,
    L: 'a,
    E: 'a,