Struct arr::Array

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

Methods

impl<T> Array<T>

pub fn iter<'a>(&'a self) -> ArrayIter<'a, T>

Create an immutable iterator over elements in Array.

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

Convert to slice

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

Convert to mutable slice

pub fn len(&self) -> usize

The length of the array (number of elements T)

impl<T> Array<T> where
    T: Zeroable, 

pub fn zero(size: usize) -> Self

Extremely fast initialization if all you want is 0's. Note that your type must be Zeroable. The auto-Zeroable types are u8, i8, u16, i16, u32, i32, u64, i64, usize, isize, f32, f64. std::Arrays also implement Zeroable allowing for types like [u8; 1 << 25].

impl<T> Array<T> where
    T: Default + Copy, 

pub fn new(size: usize) -> Self

Easy initialization if all you want is your T's default instantiation

impl<T> Array<T> where
    T: Clone, 

pub fn new_from_template(size: usize, template: &T) -> Self

More generic initialization instantiating all elements as copies of some template

Trait Implementations

impl<T> Drop for Array<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Index<Range<usize>> for Array<T>

type Output = [T]

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Array<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> IndexMut<Range<usize>> for Array<T>

fn index_mut<'a>(&'a mut self, idx: Range<usize>) -> &'a mut Self::Output

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

impl<T> IndexMut<usize> for Array<T>

fn index_mut<'a>(&'a mut self, idx: usize) -> &'a mut Self::Output

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

impl<'a, T> IntoIterator for &'a Array<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = ArrayIter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

For now, you can only for loop iterate directly over the reference:

use arr::Array;
let arr: Array<usize> = Array::new(6);
for i in &arr {
    println!("{}", i);
}

impl<T> Send for Array<T>

impl<T> Sync for Array<T>