Struct toodee::TooDee

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

Represents a two-dimensional array.

Empty arrays will always have dimensions of zero.

Implementations

impl<T> TooDee<T>

pub fn new(num_cols: usize, num_rows: usize) -> TooDee<T> where
    T: Default + Clone, 

Create a new TooDee array of the specified dimensions, and fill it with the type's default value.

Panics

Panics if one of the dimensions is zero but the other is non-zero. This is to enforce the rule that empty arrays have no dimensions.

Examples

use toodee::{TooDee,TooDeeOps};
let toodee : TooDee<u32> = TooDee::new(10, 5);
assert_eq!(toodee.num_cols(), 10);
assert_eq!(toodee.num_rows(), 5);
assert_eq!(toodee[0][0], 0);

pub fn init(num_cols: usize, num_rows: usize, init_value: T) -> TooDee<T> where
    T: Clone, 

Create a new TooDee array of the specified dimensions, and fill it with an initial value.

Panics

Panics if one of the dimensions is zero but the other is non-zero. This is to enforce the rule that empty arrays have no dimensions.

Examples

use toodee::{TooDee,TooDeeOps};
let toodee = TooDee::init(10, 5, 42u32);
assert_eq!(toodee.num_cols(), 10);
assert_eq!(toodee.num_rows(), 5);
assert_eq!(toodee[0][0], 42);

pub fn capacity(&self) -> usize

Returns the element capacity of the underlying Vec.

Examples

use toodee::TooDee;
let v = vec![42u32; 10];
let toodee : TooDee<u32> = TooDee::from_vec(5, 2, v);
assert!(toodee.capacity() >= 10);

pub fn with_capacity(capacity: usize) -> TooDee<T>

Constructs a new, empty TooDee<T> with the specified element capacity.

Examples

use toodee::TooDee;
let toodee : TooDee<u32> = TooDee::with_capacity(50);
assert!(toodee.capacity() >= 50);

pub fn reserve_exact(&mut self, capacity: usize)

Reserves the minimum capacity for at least additional more elements to be inserted into the TooDee<T>.

Examples

use toodee::TooDee;
let mut toodee : TooDee<u32> = TooDee::default();
toodee.reserve_exact(50);
assert_eq!(toodee.capacity(), 50);

pub fn reserve(&mut self, capacity: usize)

Reserves capacity for at least additional more elements to be inserted in the given TooDee<T>.

Examples

use toodee::TooDee;
let mut toodee : TooDee<u32> = TooDee::default();
toodee.reserve(50);
assert!(toodee.capacity() >= 50);

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the underlying vector as much as possible.

Examples

use toodee::TooDee;
let mut toodee : TooDee<u32> = TooDee::with_capacity(50);
toodee.shrink_to_fit();
assert_eq!(toodee.capacity(), 0);

pub fn from_vec(num_cols: usize, num_rows: usize, v: Vec<T>) -> TooDee<T>

Create a new TooDee array using the provided vector. The vector's length must match the dimensions of the array.

Panics

Panics if one of the dimensions is zero but the other is non-zero. This is to enforce the rule that empty arrays have no dimensions.

Examples

use toodee::{TooDee,TooDeeOps};
let v = vec![42u32; 10];
let mut toodee : TooDee<u32> = TooDee::from_vec(5, 2, v);
assert_eq!(toodee.num_cols(), 5);
assert_eq!(toodee.num_rows(), 2);
assert_eq!(toodee[0][0], 42);

pub fn from_box(num_cols: usize, num_rows: usize, b: Box<[T]>) -> TooDee<T>

Create a new TooDee array using the provided boxed slice. The slice's length must match the dimensions of the array.

Examples

use toodee::{TooDee,TooDeeOps};
let v = vec![42u32; 10];
let mut toodee : TooDee<u32> = TooDee::from_box(5, 2, v.into_boxed_slice());
assert_eq!(toodee.num_cols(), 5);
assert_eq!(toodee.num_rows(), 2);
assert_eq!(toodee[0][0], 42);

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

Returns a reference to the raw array data

Examples

use toodee::{TooDee,TooDeeOps};
let v = vec![42u32; 10];
let mut toodee : TooDee<u32> = TooDee::from_vec(5, 2, v);
assert_eq!(toodee.data()[0], 42);

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

Returns a mutable reference to the raw array data

Examples

use toodee::{TooDee,TooDeeOps};
let v = vec![42u32; 10];
let mut toodee : TooDee<u32> = TooDee::from_vec(5, 2, v);
assert_eq!(toodee.data_mut()[0], 42);

pub fn clear(&mut self)

Clears the array, removing all values and zeroing the number of columns and rows.

Note that this method has no effect on the allocated capacity of the array.

Examples

use toodee::{TooDee,TooDeeOps};
let v = vec![42u32; 10];
let mut toodee : TooDee<u32> = TooDee::from_vec(5, 2, v);
toodee.clear();
assert_eq!(toodee.num_cols(), 0);
assert_eq!(toodee.num_rows(), 0);
assert!(toodee.capacity() >= 10);

pub fn pop_row(&mut self) -> Option<DrainRow<'_, T>>

Removes the last row from the array and returns it as a Drain, or None if it is empty.

Examples

use toodee::{TooDee,TooDeeOps};
let v = vec![42u32; 15];
let mut toodee : TooDee<u32> = TooDee::from_vec(5, 3, v);
{
   let drain = toodee.pop_row().unwrap();
   assert_eq!(drain.len(), 5);
}
assert_eq!(toodee.num_cols(), 5);
assert_eq!(toodee.num_rows(), 2);

pub fn push_row<I>(&mut self, data: impl IntoIterator<Item = T, IntoIter = I>) where
    I: Iterator<Item = T> + ExactSizeIterator, 

Appends a new row to the array.

Panics

Panics if the data's length doesn't match the length of existing rows (if any).

pub fn insert_row<I>(
    &mut self,
    index: usize,
    data: impl IntoIterator<Item = T, IntoIter = I>
) where
    I: Iterator<Item = T> + ExactSizeIterator, 

Inserts new data into the array at the specified row

Panics

Panics if the data's length doesn't match the length of existing rows (if any).

pub fn remove_row(&mut self, index: usize) -> DrainRow<'_, T>

Removes the specified row from the array and returns it as a Drain

Panics

Panics if the specified row index is out of bounds.

Examples

use toodee::{TooDee,TooDeeOps};
let v = vec![42u32; 15];
let mut toodee : TooDee<u32> = TooDee::from_vec(5, 3, v);
{
   let drain = toodee.remove_row(1);
   assert_eq!(drain.len(), 5);
}
assert_eq!(toodee.num_cols(), 5);
assert_eq!(toodee.num_rows(), 2);

pub fn pop_col(&mut self) -> Option<DrainCol<'_, T>>

Removes the last column from the array and returns it as a Drain, or None if it is empty.

Examples

use toodee::{TooDee,TooDeeOps};
let v = vec![42u32; 15];
let mut toodee : TooDee<u32> = TooDee::from_vec(5, 3, v);
{
   let drain = toodee.pop_col().unwrap();
   assert_eq!(drain.len(), 3);
}
assert_eq!(toodee.num_cols(), 4);
assert_eq!(toodee.num_rows(), 3);

pub fn push_col<I>(&mut self, data: impl IntoIterator<Item = T, IntoIter = I>) where
    I: Iterator<Item = T> + ExactSizeIterator + DoubleEndedIterator, 

Appends a new column to the array.

Panics

Panics if the data's length doesn't match the length of existing rows (if any).

pub fn remove_col(&mut self, index: usize) -> DrainCol<'_, T>

Removes the specified column from the array and returns it as a Drain

Panics

Panics if the specified column index is out of bounds.

Examples

use toodee::{TooDee,TooDeeOps};
let v = vec![42u32; 15];
let mut toodee : TooDee<u32> = TooDee::from_vec(5, 3, v);
{
   let drain = toodee.remove_col(1);
   assert_eq!(drain.len(), 3);
}
assert_eq!(toodee.num_cols(), 4);
assert_eq!(toodee.num_rows(), 3);

pub fn insert_col<I>(
    &mut self,
    index: usize,
    data: impl IntoIterator<Item = T, IntoIter = I>
) where
    I: Iterator<Item = T> + ExactSizeIterator + DoubleEndedIterator, 

Inserts new data into the array at the specified col.

Panics

Panics if the data's length doesn't match the length of existing columns (if any).

Trait Implementations

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

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

Performs the conversion.

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

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

Performs the conversion.

impl<T> AsRef<Vec<T, Global>> for TooDee<T>

We can allow immutable access to the underlying Vec, mut not mutable access because that could lead to changes in the Vec's length.

fn as_ref(&self) -> &Vec<T>

Performs the conversion.

impl<T: Clone> Clone for TooDee<T>

fn clone(&self) -> TooDee<T>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> CopyOps<T> for TooDee<T>

fn copy_from_slice(&mut self, src: &[T]) where
    T: Copy, 

Copies data from another slice into this area. The source slice's length must match the size of this object's area. Data is copied row by row.

fn clone_from_slice(&mut self, src: &[T]) where
    T: Clone, 

Clones data from another slice into this area. The source slice's length must match the size of this object's area. Data is cloned row by row.

fn copy_from_toodee(&mut self, src: &impl TooDeeOps<T>) where
    T: Copy, 

Copies data from another TooDeeOps object into this one. The source and destination dimensions must match.

fn clone_from_toodee(&mut self, src: &impl TooDeeOps<T>) where
    T: Clone, 

Copies data from another TooDeeOps object into this one. The source and destination dimensions must match.

fn copy_within(&mut self, src: (Coordinate, Coordinate), dest: Coordinate) where
    T: Copy, 

Copies the src area (top-left to bottom-right) to a destination area. dest specifies the top-left position of destination area. The src area will be partially overwritten if the regions overlap.

impl<T> Debug for TooDee<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T> Default for TooDee<T>

Custom Default implementation because T does not need to implement Default. See rust issue #26925

fn default() -> Self

Examples

use toodee::TooDee;
struct Abc { }
let toodee : TooDee<Abc> = TooDee::default();

impl<T: Eq> Eq for TooDee<T>

impl<T> From<TooDeeView<'_, T>> for TooDee<T> where
    T: Clone, 

fn from(view: TooDeeView<'_, T>) -> Self

Performs the conversion.

impl<T> From<TooDeeViewMut<'_, T>> for TooDee<T> where
    T: Clone, 

fn from(view: TooDeeViewMut<'_, T>) -> Self

Performs the conversion.

impl<T: Hash> Hash for TooDee<T>

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

Feeds this value into the given Hasher.

pub 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 TooDee<T>

type Output = T

The returned type after indexing.

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

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let toodee : TooDee<u32> = TooDee::new(10, 5);
assert_eq!(toodee[(1,3)], 0);

impl<T> Index<usize> for TooDee<T>

type Output = [T]

The returned type after indexing.

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

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let toodee : TooDee<u32> = TooDee::new(10, 5);
let row = &toodee[3];
assert_eq!(row.len(), 10);

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

fn index_mut(&mut self, coord: Coordinate) -> &mut Self::Output

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let toodee : TooDee<u32> = TooDee::new(10, 5);
assert_eq!(toodee[(1,3)], 0);

impl<T> IndexMut<usize> for TooDee<T>

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

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let mut toodee : TooDee<u32> = TooDee::new(10, 5);
let mut row = &mut toodee[3];
row[0] = 42;

impl<T> IntoIterator for TooDee<T>

Use Vec's IntoIter for performance reasons.

TODO: return type that implements TooDeeIterator

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIterTooDee<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Cells<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Cells is the preferred iterator type here, because it implements TooDeeIterator

impl<'a, T> IntoIterator for &'a mut TooDee<T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = CellsMut<'a, T>

CellsMut is the preferred iterator type here, because it implements TooDeeIterator

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq> PartialEq<TooDee<T>> for TooDee<T>

fn eq(&self, other: &TooDee<T>) -> bool

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

fn ne(&self, other: &TooDee<T>) -> bool

This method tests for !=.

impl<T> StructuralEq for TooDee<T>

impl<T> StructuralPartialEq for TooDee<T>

impl<T> TooDeeOps<T> for TooDee<T>

fn num_cols(&self) -> usize

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let toodee : TooDee<u32> = TooDee::new(10, 5);
assert_eq!(toodee.num_cols(), 10);

fn num_rows(&self) -> usize

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let toodee : TooDee<u32> = TooDee::new(10, 5);
assert_eq!(toodee.num_rows(), 5);

fn bounds(&self) -> (Coordinate, Coordinate)

Examples

use toodee::{TooDee,TooDeeOps};
let toodee : TooDee<u32> = TooDee::new(10, 5);
assert_eq!(toodee.bounds(), ((0, 0), (10, 5)));

fn view(&self, start: Coordinate, end: Coordinate) -> TooDeeView<'_, T>

Examples

use toodee::{TooDee,TooDeeOps};
let toodee : TooDee<u32> = TooDee::new(10, 5);
let view = toodee.view((1,2), (8,4));
assert_eq!(view.num_cols(), 7);
assert_eq!(view.num_rows(), 2);

fn rows(&self) -> Rows<'_, T>

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let mut toodee : TooDee<u32> = TooDee::new(10, 5);
let mut rows = toodee.rows();
assert_eq!(rows.len(), 5);
let r0 = rows.next().unwrap();
assert_eq!(r0.len(), 10);

fn col(&self, col: usize) -> Col<'_, T>

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let mut toodee : TooDee<u32> = TooDee::new(10, 5);
let mut col = toodee.col(8);
assert_eq!(col.len(), 5);

unsafe fn get_unchecked_row(&self, row: usize) -> &[T]

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
unsafe {
    let toodee : TooDee<u32> = TooDee::new(10, 5);
    let row = toodee.get_unchecked_row(3);
    assert_eq!(row.len(), 10);
}

unsafe fn get_unchecked(&self, coord: Coordinate) -> &T

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let toodee : TooDee<u32> = TooDee::new(10, 5);
unsafe {
    assert_eq!(*toodee.get_unchecked((1,3)), 0);
}

fn size(&self) -> (usize, usize)

Returns the size/dimensions of the current object.

fn is_empty(&self) -> bool

Returns true if the array contains no elements.

fn cells(&self) -> Cells<'_, T>

Returns an iterator that traverses all cells within the area.

impl<T> TooDeeOpsMut<T> for TooDee<T>

fn view_mut(
    &mut self,
    start: Coordinate,
    end: Coordinate
) -> TooDeeViewMut<'_, T>

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let mut toodee : TooDee<u32> = TooDee::new(10, 5);
let view = toodee.view_mut((1,2), (8,4));
assert_eq!(view.num_cols(), 7);
assert_eq!(view.num_rows(), 2);

fn rows_mut(&mut self) -> RowsMut<'_, T>

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let mut toodee : TooDee<u32> = TooDee::new(10, 5);
let mut rows = toodee.rows_mut();
assert_eq!(rows.len(), 5);
let r0 = rows.next().unwrap();
assert_eq!(r0.len(), 10);

fn col_mut(&mut self, col: usize) -> ColMut<'_, T>

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let mut toodee : TooDee<u32> = TooDee::new(10, 5);
let mut col = toodee.col_mut(8);
assert_eq!(col.len(), 5);

fn fill(&mut self, fill: T) where
    T: Clone, 

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let mut toodee : TooDee<u32> = TooDee::new(10, 5);
toodee.fill(42);
assert_eq!(toodee[1][1], 42);

fn swap_rows(&mut self, r1: usize, r2: usize)

Swap/exchange the data between two rows.

Panics

Panics if either row index is out of bounds.

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let mut toodee : TooDee<u32> = TooDee::init(10, 5, 42u32);
toodee[0].iter_mut().for_each(|v| *v = 1);
assert_eq!(toodee[(0, 2)], 42);
toodee.swap_rows(0, 2);
assert_eq!(toodee[(0, 2)], 1);

unsafe fn get_unchecked_row_mut(&mut self, row: usize) -> &mut [T]

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
unsafe {
    let mut toodee : TooDee<u32> = TooDee::new(10, 5);
    let row = toodee.get_unchecked_row_mut(3);
    assert_eq!(row.len(), 10);
}

unsafe fn get_unchecked_mut(&mut self, coord: Coordinate) -> &mut T

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let mut toodee : TooDee<u32> = TooDee::new(10, 5);
unsafe {
    assert_eq!(*toodee.get_unchecked_mut((1,3)), 0);
}

fn cells_mut(&mut self) -> CellsMut<'_, T>

Returns an iterator that traverses all cells within the area.

fn swap_cols(&mut self, c1: usize, c2: usize)

Swap/exchange the data between two columns.

fn row_pair_mut(&mut self, r1: usize, r2: usize) -> (&mut [T], &mut [T])

Return the specified rows as mutable slices.