Struct Jagged2 

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

2-dimensional jagged array type. It’s equivalent to a Box<Box<[mut T]>>, but where all array data is stored contiguously and fewer allocations are performed.

Note that no dimension of the array can be modified after creation.

Jagged arrays can be created via the Jagged2Builder type or the from_iter method.

Implementations

impl<T> Jagged2<T>

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

Index into the jagged array. The index is given in (Major, Minor) form, i.e. (row, column) or (outer, inner).

Example

use std::iter::FromIterator;
use jagged_array::Jagged2;
let a = Jagged2::from_iter(vec![
    vec![1, 2, 3],
    vec![4],
    vec![],
    vec![5, 6],
]);
assert_eq!(a.get([1, 0]), Some(&4));
assert_eq!(a.get([2, 0]), None);

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

Index into the jagged array. The index is given in (Major, Minor) form, i.e. (row, column) or (outer, inner).

Example

use std::iter::FromIterator;
use jagged_array::Jagged2;
let mut a = Jagged2::from_iter(vec![
    vec![1, 2, 3],
    vec![4],
    vec![],
    vec![5, 6],
]);
assert_eq!(a.get([1, 0]), Some(&4));
*a.get_mut([1, 0]).unwrap() = 11;
assert_eq!(a.get([1, 0]), Some(&11));

pub fn get_row(&self, row: usize) -> Option<&[T]>

Retrieve the given row as a contiguous slice of memory.

Example

use std::iter::FromIterator;
use jagged_array::Jagged2;
let a = Jagged2::from_iter(vec![
    vec![1, 2, 3],
    vec![4],
    vec![],
    vec![5, 6],
]);
assert_eq!(a.get_row(3), Some(&[5, 6][..]));

pub fn get_row_mut(&mut self, row: usize) -> Option<&mut [T]>

Retrieve the given row as a contiguous slice of mutable memory.

Example

use std::iter::FromIterator;
use jagged_array::Jagged2;
let mut a = Jagged2::from_iter(vec![
    vec![1, 2, 3],
    vec![4],
    vec![],
    vec![5, 6],
]);
assert_eq!(a.get_row_mut(3), Some(&mut[5, 6][..]));
a.get_row_mut(3).unwrap()[1] = 11;
assert_eq!(a[[3, 1]], 11);

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

Return a slice over the entire storage area.

Example

use std::iter::FromIterator;
use jagged_array::Jagged2;
let a = Jagged2::from_iter(vec![
    vec![1, 2, 3],
    vec![4],
    vec![],
    vec![5, 6],
]);
assert_eq!(a.as_flat_slice(), &[1, 2, 3, 4, 5, 6][..]);

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

Return a mutable slice over the entire storage area.

Example

use std::iter::FromIterator;
use jagged_array::Jagged2;
let mut a = Jagged2::from_iter(vec![
    vec![1, 2, 3],
    vec![4],
    vec![],
    vec![5, 6],
]);
assert_eq!(a.as_flat_slice()[3], 4);
a.as_flat_slice_mut()[3] = 33;
assert_eq!(a[[1, 0]], 33);

pub fn flat_len(&self) -> usize

Return the total number of T held in the array.

This is generally a constant-time operation, but if T is a zero-sized type then the time complexity is proportional to the number of rows in the array.

Example

use std::iter::FromIterator;
use jagged_array::Jagged2;
let a = Jagged2::from_iter(vec![
    vec![1, 2, 3],
    vec![4],
    vec![],
    vec![5, 6],
]);
assert_eq!(a.flat_len(), 6);

pub fn len(&self) -> usize

Return the number of rows held in the array.

Example

use std::iter::FromIterator;
use jagged_array::Jagged2;
let a = Jagged2::from_iter(vec![
    vec![1, 2, 3],
    vec![4],
    vec![],
    vec![5, 6],
]);
assert_eq!(a.len(), 4);

pub fn is_empty(&self) -> bool

Return true if the array holds no items. Semantically equivalent to jagged2.len() == 0.

pub fn stream<'a>(&'a self) -> Stream<'a, T>

Create a streaming iterator over the rows of this array. Lifetime restrictions prevent implementing std::iter::Iterator for this type, however a streaming iterator provides similar features except that the lifetime of the items it yields is tied to the lifetime of the iterator itself.

Example

use std::iter::FromIterator;
use jagged_array::Jagged2;
use streaming_iterator::StreamingIterator;

let a = Jagged2::from_iter(vec![
    vec![1, 2, 3],
    vec![4],
]);
let mut iter = a.stream();
while let Some(row) = iter.next() {
    println!("row: {:?}", row);
}

pub fn into_boxed_slice(self) -> Box<[T]>

Consumes self and returns the underlying storage (identical to as_flat_slice_mut, but owned).

The slice can optionally be turned into a vector by calling slice::into_vec() on the result.

Trait Implementations

impl<T> Clone for Jagged2<T>

where T: Clone,

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

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Jagged2<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Jagged2<T>

where T: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Jagged2<T>, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Drop for Jagged2<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T, ICol> FromIterator<ICol> for Jagged2<T>

where ICol: IntoIterator<Item = T>,

fn from_iter<IRow>(row_iter: IRow) -> Self

where IRow: IntoIterator<Item = ICol>,

Allow construction from any type that behaves like [[T]].

Example

use std::iter::FromIterator;
use jagged_array::Jagged2;
let a = Jagged2::from_iter(vec![
    vec![1, 2, 3],
    vec![4],
    vec![],
    vec![5, 6],
]);
assert_eq!(a.len(), 4); // 4 rows
assert_eq!(a.as_flat_slice(), &[1, 2, 3, 4, 5, 6][..]); // contiguous view
assert_eq!(a.get_row(3), Some(&[5, 6][..])); // third row
assert_eq!(a[[0, 1]], 2); // first row, second column

impl<T> Hash for Jagged2<T>

where T: Hash,

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

where H: Hasher,

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; 2]> for Jagged2<T>

fn index(&self, index: [usize; 2]) -> &T

Index into the jagged array. The index is given in (Major, Minor) form, i.e. (row, column) or (outer, inner). array[[0, 0]] is adjacent to array[[0, 1]] in memory but not necessarily to array[[1, 0]].

type Output = T

The returned type after indexing.

impl<T> Into<Jagged2<T>> for Jagged2Builder<T>

fn into(self) -> Jagged2<T>

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

impl<T> PartialEq for Jagged2<T>

where T: PartialEq,

fn eq(&self, other: &Jagged2<T>) -> 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> Serialize for Jagged2<T>

where T: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Eq for Jagged2<T>

where T: Eq,