Struct toodee::TooDeeViewMut

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

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

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

Formats the value using the given formatter.

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

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

Converts to this type from the input type.

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

fn from(v: TooDeeViewMut<'a, T>) -> TooDeeView<'a, T>

Converts to this type from the input type.

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, Self: Sized,

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

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = FlattenExact<Rows<'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 = FlattenExact<RowsMut<'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: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

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

Examples

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

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

Examples

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

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. Note that the Col iterator is indexable.

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 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 mut view = toodee.view_mut((0,0), (10,5));
    let row = view.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);
let mut view = toodee.view_mut((0,0), (10,5));
unsafe {
    assert_eq!(*view.get_unchecked_mut((1,3)), 0);
}

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. Note that the ColMut iterator is indexable.

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.

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

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

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

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