Struct toodee::TooDeeViewMut

pub struct TooDeeViewMut<'a, T> { /* fields omitted */ }

Provides a mutable view (or subset), of a TooDee array.

Implementations

impl<'a, T> TooDeeViewMut<'a, T>

pub fn new(
    num_cols: usize,
    num_rows: usize,
    data: &'a mut [T]
) -> TooDeeViewMut<'a, T>

Create a new TooDeeViewMut using the provided mutable slice reference.

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.

Panics if the slice's length is not sufficient to represent the desired array dimensions.

Examples

use toodee::TooDeeViewMut;
let mut data = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
let view_mut = TooDeeViewMut::new(4, 3, &mut data);

Trait Implementations

impl<T, '_> CopyOps<T> for TooDeeViewMut<'_, 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 TooDeeViewMut<'_, T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<'a, T: Eq> Eq for TooDeeViewMut<'a, T>

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

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

Performs the conversion.

impl<'a, T: Hash> Hash for TooDeeViewMut<'a, T>

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

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<'a, T> Index<(usize, usize)> for TooDeeViewMut<'a, T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a, T> Index<usize> for TooDeeViewMut<'a, T>

type Output = [T]

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a, T> IndexMut<(usize, usize)> for TooDeeViewMut<'a, T>

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

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

impl<'a, T> IndexMut<usize> for TooDeeViewMut<'a, T>

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

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

impl<'a, T> Into<TooDeeView<'a, T>> for TooDeeViewMut<'a, T>

fn into(self) -> TooDeeView<'a, T>

Performs the conversion.

impl<'a, T> IntoIterator for &'a TooDeeViewMut<'a, 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

Creates an iterator from a value.

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

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = CellsMut<'a, 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: PartialEq> PartialEq<TooDeeViewMut<'a, T>> for TooDeeViewMut<'a, T>

fn eq(&self, other: &TooDeeViewMut<'a, T>) -> bool

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

fn ne(&self, other: &TooDeeViewMut<'a, T>) -> bool

This method tests for !=.

impl<T, '_> SortOps<T> for TooDeeViewMut<'_, 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<'a, T> StructuralEq for TooDeeViewMut<'a, T>

impl<'a, T> StructuralPartialEq for TooDeeViewMut<'a, T>

impl<'a, T> TooDeeOps<T> for TooDeeViewMut<'a, T>

fn num_rows(&self) -> usize

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

fn num_cols(&self) -> usize

The number of columns 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 an entire row.

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<'a, T> TooDeeOpsMut<T> for TooDeeViewMut<'a, 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 an entire row.

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

Returns a mutable iterator over a single column.

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);

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

Returns an iterator that traverses all cells within the area.

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

Fills the entire area with the specified value.

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.

impl<T, '_> TranslateOps<T> for TooDeeViewMut<'_, T>

fn translate_with_wrap(&mut self, mid: Coordinate)

Translate (or scroll) the entire area. The mid coordinate will be moved to (0, 0), and all other elements will be moved in the same fashion. All the original data is preserved by wrapping at the array edges.

fn flip_rows(&mut self)

Flips (or mirrors) the rows.

fn flip_cols(&mut self)

Flips (or mirrors) the columns.