Struct A 

pub struct A<'a, X> {
    pub ptr: NonNull<X>,
    pub L: u32,
    pub own: bool,
    pub Rev: bool,
    /* private fields */
}

a static length, copy-on-write vector type with element type X

Fields

ptr: NonNull<X>

ptr to the buffer of elements

L: u32

vector length

own: bool

do we own this buffer?

Rev: bool

is this buffer reversed?

Implementations

impl<'a, X> A<'a, X>

pub fn empty(len: usize) -> A<'a, X>

allocate an empty buffer of X. not really useful by itself.

pub fn from_ptr(ptr: NonNull<X>, L: u32, Rev: bool) -> A<'a, X>

make a non-owned A from a ptr with length L

pub unsafe fn ptr_add(&self, i: usize) -> *mut X

add i to the buffer ptr

pub unsafe fn ptr_add_NN(&self, i: usize) -> NonNull<X>

add i to the buffer ptr and make it NonNull

pub fn len(&self) -> usize

pub fn rev<'b>(&'b self) -> A<'a, X>

where 'b: 'a,

return the vector with the reverse flag set

pub fn rev_mut(&mut self)

reverse in place

pub fn mkref<'b>(&'b self) -> A<'a, X>

where 'b: 'a,

pub unsafe fn set_nocpy(&mut self, i: usize, x: X)

set a value in the buffer. THIS WRevITE DOES NOT COPY.

this function is only safe to use if you know that the buffer is owned (ie you just allocated it with empty). otherwise, the change will be propagated to all As that have ever been derived from this same buffer.

pub unsafe fn at_nochk(&self, i: usize) -> X

get a value from the buffer without checking the boundary.

pub fn drop<'b>(&'b self, n: u32) -> A<'a, X>

where 'b: 'a,

drop elements from the beginning of a vector

pub fn cutC<'b>(&'b self, w: u32) -> A<'a, A<'a, X>>

where 'b: 'a,

cut an A into a matrix by columns (vertically).

impl<'a, X> A<'a, X>

where X: Copy + Into<usize>, usize: Into<X>,

pub fn iota(x: X) -> A<'a, X>

Trait Implementations

impl<'a, X> Clone for A<'a, X>

fn clone(&self) -> Self

clone() on A is actually a copy/ref

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

Performs copy-assignment from source.

impl<'a, X: Debug> Debug for A<'a, X>

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

Formats the value using the given formatter.

impl<'a, X> Display for A<'a, X>

where X: Display,

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

Formats the value using the given formatter.

impl<'a, X> Drop for A<'a, X>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<'a, X> Index<usize> for A<'a, X>

type Output = X

The returned type after indexing.

fn index(&self, idx: usize) -> &'a Self::Output

Performs the indexing (container[index]) operation.

impl<'a, X> Into<A<'a, X>> for Vec<X>

fn into(self) -> A<'a, X>

Converts this type into the (usually inferred) input type.

impl<'a, X> PartialEq for A<'a, X>

where X: PartialEq,

fn eq(&self, y: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.