Trait toodee::TooDeeOpsMut[][src]

pub trait TooDeeOpsMut<T>: TooDeeOps<T> + IndexMut<usize, Output = [T]> + IndexMut<Coordinate, Output = T> {
    fn view_mut(
        &mut self,
        start: Coordinate,
        end: Coordinate
    ) -> TooDeeViewMut<'_, T>;
fn rows_mut(&mut self) -> RowsMut<'_, T>

Notable traits for RowsMut<'a, T>

impl<'a, T> Iterator for RowsMut<'a, T> type Item = &'a mut [T];
;
fn col_mut(&mut self, col: usize) -> ColMut<'_, T>

Notable traits for ColMut<'a, T>

impl<'a, T> Iterator for ColMut<'a, T> type Item = &'a mut T;
;
unsafe fn get_unchecked_row_mut(&mut self, row: usize) -> &mut [T];
unsafe fn get_unchecked_mut(&mut self, coord: Coordinate) -> &mut T; fn cells_mut(&mut self) -> CellsMut<'_, T> { ... }
fn fill(&mut self, fill: T)
    where
        T: Clone
, { ... }
fn swap_cols(&mut self, c1: usize, c2: usize) { ... }
fn swap_rows(&mut self, r1: usize, r2: usize) { ... }
fn row_pair_mut(&mut self, r1: usize, r2: usize) -> (&mut [T], &mut [T]) { ... } }

Defines operations common to both TooDee and TooDeeViewMut. Default implementations are provided where possible/practical.

Required methods

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

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

Examples

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

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

Notable traits for RowsMut<'a, T>

impl<'a, T> Iterator for RowsMut<'a, T> type Item = &'a mut [T];
[src]

Returns a mutable iterator of slices, where each slice represents an entire row.

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let mut toodee : TooDee<u32> = TooDee::init(10, 5, 42u32);
for (i, r) in toodee.rows_mut().enumerate() {
   r.iter_mut().for_each(|c| *c -= i as u32);
}
assert_eq!(toodee.cells().sum::<u32>(), 42*50 - 10 - 20 - 30 - 40);

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

Notable traits for ColMut<'a, T>

impl<'a, T> Iterator for ColMut<'a, T> type Item = &'a mut T;
[src]

Returns a mutable iterator over a single column. Note that the ColMut iterator is indexable.

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let mut toodee : TooDee<u32> = TooDee::init(10, 5, 42u32);
for c in toodee.col_mut(4) {
    *c /= 2;
}
assert_eq!(toodee.cells().sum::<u32>(), 42*45 + 21*5);

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

Returns a mutable row without checking that the row is valid. Generally it's best to use indexing instead, e.g., toodee[row]

Safety

This is generally not recommended, use with caution! Calling this method with an invalid row is [undefined behavior] even if the resulting reference is not used.

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

Returns a mutable cell without checking that the cell coordinate is valid. Generally it's best to use indexing instead, e.g., toodee[(col, row)]

Safety

This is generally not recommended, use with caution! Calling this method with an invalid coordinate is [undefined behavior] even if the resulting reference is not used.

Loading content...

Provided methods

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

Returns an iterator that traverses all cells within the area.

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let mut toodee : TooDee<u32> = TooDee::init(10, 5, 42u32);
for c in toodee.cells_mut() {
    *c -= 1;
}
assert_eq!(toodee.cells().sum::<u32>(), 41*50);

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

Fills the entire area with the specified value.

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let mut toodee : TooDee<u32> = TooDee::init(10, 5, 42u32);
let mut view = toodee.view_mut((1, 1), (9, 4));
view.fill(0);
assert_eq!(toodee.cells().sum::<u32>(), 42*(50 - 8*3));

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

Swap/exchange the data between two columns.

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let mut toodee : TooDee<u32> = TooDee::init(10, 5, 42u32);
for c in toodee.col_mut(2) {
    *c = 1;
}
assert_eq!(toodee[(4, 0)], 42);
toodee.swap_cols(2, 4);
assert_eq!(toodee[(4, 0)], 1);

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

Swap/exchange the data between two rows. Note that this method is overridden in both TooDee and TooDeeOpsMut. This implementation remains in place for other types that may wish to implement the trait.

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.view_mut((0, 0), (10, 5)).swap_rows(0, 2);
assert_eq!(toodee[(0, 2)], 1);

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

Return the specified rows as mutable slices.

Panics

Will panic if r1 and r2 are equal, or if either row index is out of bounds.

Examples

use toodee::{TooDee,TooDeeOps,TooDeeOpsMut};
let mut toodee : TooDee<u32> = TooDee::init(10, 5, 42u32);
let (r1, r2) = toodee.row_pair_mut(0, 4);
// do something with the row pair
r1.swap_with_slice(r2);
Loading content...

Implementors

impl<'a, T> TooDeeOpsMut<T> for TooDeeViewMut<'a, T>[src]

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

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][src]

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[src]

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

impl<T> TooDeeOpsMut<T> for TooDee<T>[src]

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

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>

Notable traits for RowsMut<'a, T>

impl<'a, T> Iterator for RowsMut<'a, T> type Item = &'a mut [T];
[src]

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>

Notable traits for ColMut<'a, T>

impl<'a, T> Iterator for ColMut<'a, T> type Item = &'a mut T;
[src]

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
[src]

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)[src]

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][src]

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[src]

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);
}
Loading content...