Struct Array

pub struct Array<T, const N: usize> { /* private fields */ }

An array type like [T; N], but providing some methods of Vec.

Implementations

impl<T, const N: usize> Array<T, N>

pub const fn new() -> Self

Creates a new empty Array.

Examples

use my_ecs::ds::Array;

let arr = Array::<i32, 2>::new();

pub const fn capacity(&self) -> usize

Returns capacity, which is N.

Examples

use my_ecs::ds::Array;

let arr = Array::<i32, 2>::new();
assert_eq!(arr.capacity(), 2);

pub const fn len(&self) -> usize

Returns number of items.

Examples

use my_ecs::ds::Array;

let mut arr = Array::<i32, 2>::new();
arr.push(0);
assert_eq!(arr.len(), 1);

pub const fn is_empty(&self) -> bool

Returns true if the array is empty.

Examples

use my_ecs::ds::Array;

let arr = Array::<i32, 2>::new();
assert!(arr.is_empty());

pub const fn is_full(&self) -> bool

Returns true if the array contains N items.

Examples

use my_ecs::ds::Array;

let mut arr = Array::<i32, 2>::new();
arr.push(0);
arr.push(1);
assert!(arr.is_full());

pub fn get(&self, index: usize) -> Option<&T>

Retrieves a shared reference to an item at the given index.

Examples

use my_ecs::ds::Array;

let mut arr = Array::<i32, 2>::new();
arr.push(0);
assert_eq!(arr.get(0), Some(&0));

pub fn get_mut(&mut self, index: usize) -> Option<&mut T>

Retrieves a mutable reference to an item at the given index.

Examples

use my_ecs::ds::Array;

let mut arr = Array::<i32, 2>::new();
arr.push(0);
assert_eq!(arr.get_mut(0), Some(&mut 0));

pub fn iter(&self) -> Iter<'_, T>

Returns iterator traversing all items.

Examples

use my_ecs::ds::Array;

let mut arr = Array::<i32, 2>::new();
arr.push(0);
arr.push(1);
for item in arr.iter() {
    println!("{item}");
}

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns mutable iterator traversing all items.

Examples

use my_ecs::ds::Array;

let mut arr = Array::<i32, 2>::new();
arr.push(0);
arr.push(1);
for item in arr.iter_mut() {
    *item += 1;
}

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

Returns &[T] from the array.

Examples

use my_ecs::ds::Array;

let arr = Array::<i32, 2>::new();
let slice: &[i32] = arr.as_slice();

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

Returns &mut [T] from the array.

Examples

use my_ecs::ds::Array;

let mut arr = Array::<i32, 2>::new();
let slice: &mut [i32] = arr.as_mut_slice();

pub fn clear(&mut self)

Removes all items in the array.

Examples

use my_ecs::ds::Array;

let mut arr = Array::<i32, 2>::new();
arr.push(0);
arr.clear();
assert!(arr.is_empty());

pub fn push(&mut self, value: T) -> bool

Appends a given item at the end of the array.

Examples

use my_ecs::ds::Array;

let mut arr = Array::<i32, 2>::new();
arr.push(0);

pub fn pop(&mut self) -> Option<T>

Takes out an item from the end of the array.

Examples

use my_ecs::ds::Array;

let mut arr = Array::<i32, 2>::new();
arr.push(0);
arr.push(1);
assert_eq!(arr.pop(), Some(1));
assert_eq!(arr.pop(), Some(0));

pub fn back(&self) -> Option<&T>

Returns shared reference to the last item.

Examples

use my_ecs::ds::Array;

let mut arr = Array::<i32, 2>::new();
arr.push(0);
arr.push(1);
assert_eq!(arr.back(), Some(&1));

pub fn front(&self) -> Option<&T>

Returns shared reference to the first item.

Examples

use my_ecs::ds::Array;

let mut arr = Array::<i32, 2>::new();
arr.push(0);
arr.push(1);
assert_eq!(arr.front(), Some(&0));

Trait Implementations

impl<T: Debug, const N: usize> Debug for Array<T, N>

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

Formats the value using the given formatter.

impl<T, const N: usize> Default for Array<T, N>

fn default() -> Self

Returns the “default value” for a type.

impl<T, const N: usize> Drop for Array<T, N>

fn drop(&mut self)

Executes the destructor for this type.

impl<T, const N: usize> Index<usize> for Array<T, N>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, const N: usize> IndexMut<usize> for Array<T, N>

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

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