Struct heaparray::HeapArray

#[repr(C)]
pub struct HeapArray<E, L = ()> { /* fields omitted */ }

Heap-allocated array, with array size stored with the pointer to the memory.

Examples

Creating an array:

use heaparray::base::*;
let len = 10;
let array = FatPtrArray::new(len, |idx| idx + 3);

Indexing works as you would expect:

array[3] = 2;
assert!(array[3] == 2);

Notably, you can take ownership of objects back from the container:

let mut array = FatPtrArray::new(10, |_| Vec::<u8>::new());
let replacement_object = Vec::new();
let owned_object = array.insert(0, replacement_object);

but you need to give the array a replacement object to fill its slot with.

Additionally, you can customize what information should be stored alongside the elements in the array using the FatPtrArray::with_label function:

struct MyLabel {
    pub even: usize,
    pub odd: usize,
}

let mut array = FatPtrArray::with_label(
    MyLabel { even: 0, odd: 0 },
    100,
    |label, index| {
        if index % 2 == 0 {
            label.even += 1;
            index
        } else {
            label.odd += 1;
            index
        }
    });

Invariants

This struct follows the same invariants as mentioned in heaparray::mem_block, and does not check for pointer validity; you should use this struct in the same way you would use a raw array or slice.

Trait Implementations

impl<E, L> BaseArrayRef for FatPtrArray<E, L>

impl<E, L> LabelledArray<E, L> for FatPtrArray<E, 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.

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.

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<E, L> LabelledArrayMut<E, L> for FatPtrArray<E, L>

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

Get mutable reference to the label.

impl<E, L> DefaultLabelledArray<E, L> for FatPtrArray<E, L> where
    E: Default, 

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

Create a new array, initialized to default values.

impl<E> MakeArray<E> for FatPtrArray<E, ()>

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<E, L> SliceArray<E> for FatPtrArray<E, L>

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

Returns a reference to a slice into this array.

fn as_slice_mut(&mut self) -> &mut [E]

Returns a mutable reference to a slice into this array.

impl<E, L> Sync for FatPtrArray<E, L> where
    E: Sync,
    L: Sync, 

impl<E, L> Send for FatPtrArray<E, L> where
    E: Send,
    L: Send, 

impl<E, L> Clone for FatPtrArray<E, L> where
    E: Clone,
    L: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E, L> IntoIterator for FatPtrArray<E, L>

type Item = E

The type of the elements being iterated over.

type IntoIter = FatPtrArrayIter<E, L>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'b, E, L> IntoIterator for &'b FatPtrArray<E, 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<'b, E, L> IntoIterator for &'b mut FatPtrArray<E, L>

type Item = &'b mut E

The type of the elements being iterated over.

type IntoIter = IterMut<'b, E>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<E, L> Drop for FatPtrArray<E, L>

fn drop(&mut self)

Executes the destructor for this type.

impl<E, L> Debug for FatPtrArray<E, L> where
    E: Debug,
    L: Debug, 

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

Formats the value using the given formatter.

impl<E, L> Index<usize> for FatPtrArray<E, L>

type Output = E

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<E, L> IndexMut<usize> for FatPtrArray<E, L>

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

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

impl<E, L> Container for FatPtrArray<E, L>

fn len(&self) -> usize

Get the size of the container.

impl<E, L> CopyMap<usize, E> for FatPtrArray<E, L>

fn get(&self, key: usize) -> Option<&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(&mut self, key: usize) -> Option<&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.