Struct RcArray

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

A reference-counted pointer to an array.

It allow access to the elements of the array with one indirection, allow the array to grow until the specified capacity and has a function RcArray::make_mut.

It is different from Rc<Vec> and Rc<[T]>. In Rc<Vec> it is necessary to follow two indirection to access an element. In Rc<[T]> the array cannot grow and the function Rc::make_mut is not applicable.

TODO: write about mem::size_of.

Examples

use fera_array::{Array, RcArray};

let a = RcArray::with_value(0, 5);
// a and b share the inner data, this is a O(1) operation
let mut b = a.clone();

// the inner data in cloned (copy on write)
b[1] = 1;
assert_eq!(0, a[1]);
assert_eq!(1, b[1]);

// the inner data is not shared, so it can be modified without being cloned
b[2] = 2;

Implementations

impl<T> RcArray<T>

pub fn as_slice(&self) -> &[T]

Returns a slice containing the entire array.

pub fn as_mut_slice(&mut self) -> &mut [T]

Returns a mutable slice containing the entire array.

impl<T: Clone> RcArray<T>

pub fn make_mut(&mut self) -> &mut [T]

Makes the array mutable. The inner data is cloned if there is more than one reference to it, otherwise the array is already mutable.

Trait Implementations

impl<T: Clone> Array<T> for RcArray<T>

fn with_value(value: T, n: usize) -> Self

where T: Clone,

Creates a new array with n repeated value.

fn len(&self) -> usize

Returns the number of elements in the array.

fn get(&self, index: usize) -> Option<&T>

Returns a reference to the element of the array at index, or None if the index is out of bounds.

fn get_mut(&mut self, index: usize) -> Option<&mut T>

Returns a mutable reference to the element of the array at index, or None if the index is out of bounds.

unsafe fn get_unchecked(&self, index: usize) -> &T

Returns a reference to the element of the array at index, without doing bounds checking.

unsafe fn get_unchecked_mut(&mut self, index: usize) -> &mut T

Returns a mutable reference to the element of the array at index, without doing bounds checking.

fn contains(&self, value: &T) -> bool

where T: PartialEq,

Returns true if the array contains value, false otherwise.

fn is_empty(&self) -> bool

Returns true if the length of the array is 0, otherwise false.

fn iter(&self) -> Iter<'_, T, Self>

where Self: Sized,

Returns a iterator over the array.

impl<T> Clone for RcArray<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> Drop for RcArray<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Clone> DynamicArray<T> for RcArray<T>

fn with_capacity(cap: usize) -> Self

Creates a array with the specified capacity.

unsafe fn set_len(&mut self, len: usize)

Change the length of the array.

fn capacity(&self) -> usize

Returns the capacity of the array.

fn reserve(&mut self, additional: usize)

Reserve capacity for at least additional more elements.

unsafe fn push_unchecked(&mut self, value: T)

Write value to the end of the array and increment the length.

fn push(&mut self, value: T)

Appends the value to the array.

fn extend<I>(&mut self, iter: I)

where Self: Sized, I: IntoIterator<Item = T>,

Appends all elements of iter to the array.

fn extend_from_slice(&mut self, other: &[T])

where T: Clone,

Appends all elements in a slice to the array.

fn extend_with_element(&mut self, value: T, n: usize)

where T: Clone,

Extend the array by n additional clones of value.

impl<T> FromIterator<T> for RcArray<T>

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = T>,

Creates a value from an iterator.

impl<T> Index<usize> for RcArray<T>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &T

Performs the indexing (container[index]) operation.

impl<T: Clone> IndexMut<usize> for RcArray<T>

fn index_mut(&mut self, index: usize) -> &mut T

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