Struct lattice_graph::fixedvec2d::FixedVec2D

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

Raw fixed 2d vector. It has two axis, horizontal and vertical. Data is stored on one Vec. Horizontal size must not be 0.

Implementations

impl<T> FixedVec2D<T>

pub fn from_raw(h: NonZeroUsize, v: usize, vec: Vec<T>) -> Option<Self>

Creates a array2d with a vec. Returns None if h * v != vec.len()

pub unsafe fn new_uninit(h: NonZeroUsize, v: usize) -> Self

Creates a FixedVec2D without initializing. It is unsafe to use it so I recomend to use with MaybeUninit or just use new. See assume_init.

pub fn new<F: FnMut(usize, usize) -> T>(h: NonZeroUsize, v: usize, f: F) -> Self

Creates a FixedVec2D with initializing from the function.

let array = FixedVec2D::new(NonZeroUsize::new(5).unwrap(), 2, |h, v| (h, v));
for i in 0..5 {
    for j in 0..2 {
        assert_eq!(array.ref_2d()[i][j], (i, j));
    }
}

pub fn h_size(&self) -> usize

Returns the horizontal size.

pub fn v_size(&self) -> usize

Returns the vertical size.

pub fn size(&self) -> usize

Returns the length of underlying Vec.

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

Returns the slice of all values in the array.

pub fn ref_2d<'a>(&self) -> &[&'a [T]]

Returns the reference of this array.

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

Returns the mutable slice of all values in the array.

pub fn mut_2d<'a>(&mut self) -> &mut [&'a mut [T]]

Returns the mutable reference of this array.

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

Returns the underlying Vec consuming this FixedVec2D

impl<T> FixedVec2D<MaybeUninit<T>>

pub unsafe fn assume_init(self) -> FixedVec2D<T>

Assume init. Use this with new_uninit.

let mut array = unsafe { FixedVec2D::<MaybeUninit<i32>>::new_uninit(NonZeroUsize::new(6).unwrap(),3) };
for i in 0..6{
    for j in 0..3{
        array.mut_2d()[i][j] = MaybeUninit::new((i + j) as i32);
    }
}
let array_init = unsafe { array.assume_init() };

Trait Implementations

impl<'a, T> AsMut<[&'a mut [T]]> for FixedVec2D<T>

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

Performs the conversion.

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

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

Performs the conversion.

impl<'a, T> AsRef<[&'a [T]]> for FixedVec2D<T>

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

Performs the conversion.

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

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

Performs the conversion.

impl<T: Clone> Clone for FixedVec2D<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: Debug> Debug for FixedVec2D<T>

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

Formats the value using the given formatter.

impl<T> Drop for FixedVec2D<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Hash> Hash for FixedVec2D<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<T> Index<(usize, usize)> for FixedVec2D<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> IndexMut<(usize, usize)> for FixedVec2D<T>

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

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

impl<T: PartialEq> PartialEq<FixedVec2D<T>> for FixedVec2D<T>

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

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

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

This method tests for !=.

impl<T: PartialEq> Eq for FixedVec2D<T>