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.

Will panic 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.

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.

Will panic 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.

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

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

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

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

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

pub fn shrink_to_fit(&mut self)

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

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.

Will panic 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.

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.

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

Returns a reference to the raw array data

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

Returns a mutable reference to the raw array data

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.

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

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

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 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 if the data's length doesn't match the length of existing rows (if any).

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

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

Panics if the specified row index is out of bounds.

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

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

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

Appends a new column to the array.

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

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

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

Panics if the specified column index is out of bounds.

pub fn insert_col<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 col.

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: Clone> Clone for TooDee<T>

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

Returns a copy of the value.

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 https://github.com/rust-lang/rust/issues/26925

fn default() -> Self

Returns the "default value" for a type.

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> Index<usize> for TooDee<T>

type Output = [T]

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

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

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

impl<T> Into<Vec<T>> for TooDee<T>

Support conversion into a Vec.

fn into(self) -> Vec<T>

Performs the conversion.

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> SortOps<T> for TooDee<T>

fn sort_row_ord<F>(&mut self, row: usize) where
    T: Ord, 

Sort the entire two-dimensional array by comparing elements on a specific row, using the natural ordering. This sort is stable.

fn sort_unstable_row_ord<F>(&mut self, row: usize) where
    T: Ord, 

Sort the entire two-dimensional array by comparing elements on a specific row, using the natural ordering. This sort is unstable.

fn sort_by_row<F>(&mut self, row: usize, compare: F) where
    F: FnMut(&T, &T) -> Ordering, 

Sort the entire two-dimensional array by comparing elements on a specific row using the provided compare function. This sort is stable.

fn sort_unstable_by_row<F>(&mut self, row: usize, compare: F) where
    F: FnMut(&T, &T) -> Ordering, 

Sort the entire two-dimensional array by comparing elements on a specific row using the provided compare function. This sort is unstable.

fn sort_by_row_key<B, F>(&mut self, row: usize, f: F) where
    B: Ord,
    F: FnMut(&T) -> B, 

Sort the entire two-dimensional array by comparing elements on a specific row using a key extraction function. This sort is stable.

fn sort_unstable_by_row_key<B, F>(&mut self, row: usize, f: F) where
    B: Ord,
    F: FnMut(&T) -> B, 

Sort the entire two-dimensional array by comparing elements on a specific row using a key extraction function. This sort is unstable.

fn sort_col_ord<F>(&mut self, col: usize) where
    T: Ord, 

Sort the entire two-dimensional array by comparing elements on a specific column using the natural ordering. This sort is stable.

fn sort_by_col<F>(&mut self, col: usize, compare: F) where
    F: FnMut(&T, &T) -> Ordering, 

Sort the entire two-dimensional array by comparing elements on in a specific column. This sort is stable.

fn sort_unstable_by_col<F>(&mut self, col: usize, compare: F) where
    F: FnMut(&T, &T) -> Ordering, 

Sort the entire two-dimensional array by comparing elements on in a specific column. This sort is unstable.

fn sort_by_col_key<B, F>(&mut self, col: usize, f: F) where
    B: Ord,
    F: FnMut(&T) -> B, 

Sort the entire two-dimensional array by comparing elements on a specific column using a key extraction function. This sort is stable.

fn sort_unstable_by_col_key<B, F>(&mut self, col: usize, f: F) where
    B: Ord,
    F: FnMut(&T) -> B, 

Sort the entire two-dimensional array by comparing elements on a specific column using a key extraction function. This sort is unstable.

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

fn num_cols(&self) -> usize

The number of columns in the area represented by this object.

fn num_rows(&self) -> usize

The number of rows in the area represented by this object.

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

Returns the bounds of the object's area within the original TooDee area (views are not nested for now).

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

Returns a view (or subset) of the current area based on the coordinates provided.

fn rows(&self) -> Rows<T>

Returns an iterator of slices, where each slice represents the entire row of the object's area.

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

Returns an iterator over a single column

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>

Returns a mutable view (or subset) of the current area based on the coordinates provided.

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

Returns a mutable iterator of slices, where each slice represents the entire row of the object's area.

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

Returns a mutable iterator over a single column

fn fill<V>(&mut self, fill: V) where
    V: Borrow<T>,
    T: Clone, 

Fills the entire area with the specified value.

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 swap_rows(&mut self, r1: usize, r2: usize)

Swap/exchange the data between two rows. Will panic if either row index is out of bounds.

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

Return the specified rows as mutable slices. Will panic if r1 and r2 are equal, or if either row index is out of bounds.

impl<T> TranslateOps<T> for TooDee<T>

fn translate_with_wrap(&mut self, mid: Coordinate)

Translate (or scroll) the area by moving col_mid to the first column and row_mid to the first row.

fn flip_rows(&mut self)

Flips (or mirrors) the rows.

fn flip_cols(&mut self)

Flips (or mirrors) the columns.