Struct arae::CurVec

pub struct CurVec<T> { /* fields omitted */ }

A heap-allocated, fixed-size, array of values in contiguous memory designed for efficient access via Cursors.

You can access the elements of a CurVec<T> the same way you would a Vec<T> or Box<[T]> however it's characteristics are different to what either provide. Unlike a Vec<T> which stores the data ptr, length and capacity a CurVec<T> stores the starting element ptr (head) and end element ptr (tail).

A CurVec<T>:

• Cannot be empty.
• Cannot contain elements of mem::size_of() == 0.
• Cannot be resized (and does not have any notion of capacity).

Conversion

• Converting from and into a Vec<T> or Box<[T]> is a zero-copy operation.
• When converting from a Vec<T> excess capacity is stripped.
• Converting from a Vec<T>, Box<[T]> or similar types will panic if their length is zero.

Example

use arae::{CurVec, CursedExt, Bounded};

// Create a new `CurVec` of length 10 with the elements
// initialized via `Default::default`.
let mut vec = CurVec::new_with_default(10);

// Create two cursors pointing the the head of the vec.
let write_cursor = vec.head();
let read_cursor = vec.head();

// Write the value `1` at the element pointed by `write_cursor`.
*vec.get_mut(write_cursor) = 1;

// Read the value at the element pointed by `read_cursor`.
assert_eq!(*vec.get(read_cursor), 1);

Methods

impl<T> CurVec<T>

pub fn new_with_init<F>(len: usize, init_fn: F) -> Self where
    F: FnMut() -> T, 

Construct a new CurVec with a given length and an element initializer that cannot fail.

pub fn try_new_with_init<F, E>(len: usize, init_fn: F) -> Result<Self, E> where
    F: FnMut() -> Result<T, E>, 

Construct a new CurVec with a given length and an element initializer that may fail.

pub unsafe fn from_raw_parts(head: NonNull<T>, len: usize) -> Self

Construct a new CurVec from its raw parts.

Panics

Panics if len is zero or greater than isize::max_value().

Safety

See the safety notes for Vec::from_raw_parts.

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

Return a slice of the elements.

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

Return a mutable slice of the elements.

pub fn into_boxed_slice(self) -> Box<[T]>

Consume self into a Box<[T]>.

pub fn into_vec(self) -> Vec<T>

Consume self into a Vec<T>.

impl<T: Default> CurVec<T>

pub fn new_with_default(len: usize) -> Self

Construct a new CurVec with a given length with elements initialized via Default::default().

Trait Implementations

impl<T> AsMut<[T]> for CurVec<T>

fn as_mut(&mut self) -> &mut [T]

Performs the conversion.

impl<T> AsRef<[T]> for CurVec<T>

fn as_ref(&self) -> &[T]

Performs the conversion.

impl<T> Bounded<T> for CurVec<T>

fn len(&self) -> usize

Returns the number of items within the sequence.

fn head(&self) -> Cursor<T>

Returns a [Cursor] pointing to the head of the sequence.

fn tail(&self) -> Cursor<T>

Returns a [Cursor] pointing to the tail of the sequence.

fn at(&self, offset: usize) -> Option<Cursor<T>>

Returns Some([Cursor]) at the given offset from the head of the sequence, None if the offset is out of bounds.

impl<T: Clone> Clone for CurVec<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> Contiguous<T> for CurVec<T>

impl<T> Cursed<T> for CurVec<T>

fn is_owner(&self, cursor: Cursor<T>) -> bool

Returns true if the [Cursor] is owned by self, false if not.

impl<T: Debug> Debug for CurVec<T>

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

Formats the value using the given formatter.

impl<T> Drop for CurVec<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> From<Box<[T]>> for CurVec<T>

fn from(value: Box<[T]>) -> Self

Performs the conversion.

impl<T> From<Vec<T>> for CurVec<T>

fn from(value: Vec<T>) -> Self

Performs the conversion.

impl<L, R> PartialEq<CurVec<R>> for CurVec<L> where
    L: PartialEq<R>, 

fn eq(&self, other: &CurVec<R>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T> Sequence<T> for CurVec<T>

fn next(&self, cursor: Cursor<T>) -> Option<Cursor<T>>

Given a [Cursor], return its next element step.

fn prev(&self, cursor: Cursor<T>) -> Option<Cursor<T>>

Given a [Cursor], return its previous element step.

fn remaining(&self, cursor: Cursor<T>) -> (usize, Option<usize>)

Given a [Cursor], return the bounds of the remaining steps.