Struct FixedVec2D

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

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 unsafe 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

pub unsafe fn forget_values(&mut self)

Drop the heads vec and forget values. This is to drop the values manually in FixedVec2D. Should drop the values first and than use this method.

struct Flag{ pub drop_count : AtomicUsize }
impl Drop for Flag {
    fn drop(&mut self) {
        assert_eq!(self.drop_count.fetch_add(1, Ordering::SeqCst), 0);
    }
}

let mut vec = FixedVec2D::<Flag>::new(
    NonZeroUsize::new(4).unwrap(),
    3,
    |i,j| Flag{ drop_count : AtomicUsize::new(0) }
);

// manually drops
vec.mut_1d().iter_mut().for_each(|f| unsafe{ std::ptr::drop_in_place(f) });
// forget
unsafe { vec.forget_values() };

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]]

Converts this type into a mutable reference of the (usually inferred) input type.

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

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

Converts this type into a mutable reference of the (usually inferred) input type.

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

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

Converts this type into a shared reference of the (usually inferred) input type.

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

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

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone> Clone for FixedVec2D<T>

fn clone(&self) -> Self

Returns a duplicate 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, Self: Sized,

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 for FixedVec2D<T>

fn eq(&self, other: &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.

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

impl<T: Send> Send for FixedVec2D<T>

impl<T: Sync> Sync for FixedVec2D<T>