Trait flatk::ViewMut

pub trait ViewMut<'a> {
    type Type: Viewed;
    fn view_mut(&'a mut self) -> Self::Type;
}

A trait defining a collection that can be accessed via a mutable (unique) view.

Associated Types

type Type: Viewed

Loading content...

Required methods

fn view_mut(&'a mut self) -> Self::Type

Loading content...

Implementations on Foreign Types

impl<'a, T: 'a> ViewMut<'a> for [T; 1]

type Type = &'a mut [T]

fn view_mut(&'a mut self) -> Self::Type

impl<'a, T: 'a> ViewMut<'a> for [T; 2]

type Type = &'a mut [T]

fn view_mut(&'a mut self) -> Self::Type

impl<'a, T: 'a> ViewMut<'a> for [T; 3]

type Type = &'a mut [T]

fn view_mut(&'a mut self) -> Self::Type

impl<'a, T: 'a> ViewMut<'a> for [T; 4]

type Type = &'a mut [T]

fn view_mut(&'a mut self) -> Self::Type

impl<'a, T: 'a> ViewMut<'a> for [T; 5]

type Type = &'a mut [T]

fn view_mut(&'a mut self) -> Self::Type

impl<'a, T: 'a> ViewMut<'a> for [T; 6]

type Type = &'a mut [T]

fn view_mut(&'a mut self) -> Self::Type

impl<'a, T: 'a> ViewMut<'a> for [T; 7]

type Type = &'a mut [T]

fn view_mut(&'a mut self) -> Self::Type

impl<'a, T: 'a> ViewMut<'a> for [T; 8]

type Type = &'a mut [T]

fn view_mut(&'a mut self) -> Self::Type

impl<'a, T: 'a> ViewMut<'a> for [T; 9]

type Type = &'a mut [T]

fn view_mut(&'a mut self) -> Self::Type

impl<'a, T: 'a> ViewMut<'a> for [T; 10]

type Type = &'a mut [T]

fn view_mut(&'a mut self) -> Self::Type

impl<'a, T: 'a> ViewMut<'a> for [T; 11]

type Type = &'a mut [T]

fn view_mut(&'a mut self) -> Self::Type

impl<'a, T: 'a> ViewMut<'a> for [T; 12]

type Type = &'a mut [T]

fn view_mut(&'a mut self) -> Self::Type

impl<'a, T: 'a> ViewMut<'a> for [T; 13]

type Type = &'a mut [T]

fn view_mut(&'a mut self) -> Self::Type

impl<'a, T: 'a> ViewMut<'a> for [T; 14]

type Type = &'a mut [T]

fn view_mut(&'a mut self) -> Self::Type

impl<'a, T: 'a> ViewMut<'a> for [T; 15]

type Type = &'a mut [T]

fn view_mut(&'a mut self) -> Self::Type

impl<'a, T: 'a> ViewMut<'a> for [T; 16]

type Type = &'a mut [T]

fn view_mut(&'a mut self) -> Self::Type

impl<'a, S: ViewMut<'a>> ViewMut<'a> for Box<S>

type Type = <S as ViewMut<'a>>::Type

fn view_mut(&'a mut self) -> Self::Type

impl<'a, T: 'a> ViewMut<'a> for [T]

type Type = &'a mut [T]

fn view_mut(&'a mut self) -> Self::Type

impl<'a, S: ViewMut<'a>, T: ViewMut<'a>> ViewMut<'a> for (S, T)

type Type = (S::Type, T::Type)

fn view_mut(&'a mut self) -> Self::Type

impl<'a, T: 'a> ViewMut<'a> for Vec<T>

type Type = &'a mut [T]

fn view_mut(&'a mut self) -> Self::Type

impl<'a, '_, S: ?Sized + 'a + ViewMut<'a>> ViewMut<'a> for &'_ mut S

Blanket implementation of ViewMut for all mutable borrows.

type Type = S::Type

fn view_mut(&'a mut self) -> Self::Type

Loading content...

Implementors

impl<'a, O: AsMut<[usize]>> ViewMut<'a> for Offsets<O>

type Type = Offsets<&'a mut [usize]>

fn view_mut(&'a mut self) -> Self::Type

impl<'a, O: AsMut<[usize]>> ViewMut<'a> for SortedChunks<O>

type Type = SortedChunks<&'a mut [usize]>

fn view_mut(&'a mut self) -> Self::Type

impl<'a, S, I> ViewMut<'a> for Select<S, I> where
    S: Set + ViewMut<'a>,
    I: AsRef<[usize]>, 

type Type = Select<S::Type, &'a [usize]>

fn view_mut(&'a mut self) -> Self::Type

Create a mutable view of this selection.

Example

use flatk::*;
let mut v = vec!['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'];
let mut selection = Select::new(vec![1,2,4,1], v.as_mut_slice());

{
    let view = selection.view();
    let mut iter = view.iter();
    assert_eq!(Some((1, &'b')), iter.next());
    assert_eq!(Some((2, &'c')), iter.next());
    assert_eq!(Some((4, &'e')), iter.next());
    assert_eq!(Some((1, &'b')), iter.next());
    assert_eq!(None, iter.next());
}

// Change all referenced elements to 'a'.
let mut view = selection.view_mut();
for &i in view.indices.iter() {
    view.target[i] = 'a';
}

let view = selection.view();
let mut iter = view.iter();
assert_eq!(Some((1, &'a')), iter.next());
assert_eq!(Some((2, &'a')), iter.next());
assert_eq!(Some((4, &'a')), iter.next());
assert_eq!(Some((1, &'a')), iter.next());
assert_eq!(None, iter.next());

impl<'a, S, I> ViewMut<'a> for Subset<S, I> where
    S: Set + ViewMut<'a>,
    I: AsRef<[usize]>, 

type Type = Subset<S::Type, &'a [usize]>

fn view_mut(&'a mut self) -> Self::Type

Create a mutable view into this subset.

Example

use flatk::*;
let mut v = vec![1,2,3,4,5];
let mut subset = Subset::from_indices(vec![0,2,4], v.as_mut_slice());
let mut view = subset.view_mut();
for i in view.iter_mut() {
    *i += 1;
}
assert_eq!(v, vec![2,2,4,4,6]);

impl<'a, S, N> ViewMut<'a> for UniChunked<S, N> where
    S: ViewMut<'a>,
    N: Copy, 

type Type = UniChunked<<S as ViewMut<'a>>::Type, N>

fn view_mut(&'a mut self) -> Self::Type

Create a UniChunked contiguous mutable (unique) view into the underlying collection.

Example

use flatk::*;
let mut s = Chunked2::from_flat(vec![0,1,2,3]);
let mut v = s.view_mut();
{
   v.iter_mut().next().unwrap()[0] = 100;
}
let mut view_iter = v.iter();
assert_eq!(Some(&[100,1]), view_iter.next());
assert_eq!(Some(&[2,3]), view_iter.next());
assert_eq!(None, view_iter.next());

impl<'a, S, O> ViewMut<'a> for Chunked<S, O> where
    S: ViewMut<'a>,
    O: View<'a>, 

type Type = Chunked<S::Type, O::Type>

fn view_mut(&'a mut self) -> Self::Type

Create a contiguous mutable (unique) view into this set.

Example

use flatk::*;
let mut s = Chunked::<Vec<usize>>::from_offsets(vec![0,1,4,6], vec![0,1,2,3,4,5]);
let mut v1 = s.view_mut();
v1.iter_mut().next().unwrap()[0] = 100;
let mut view1_iter = v1.iter();
assert_eq!(Some(&[100][..]), view1_iter.next());
assert_eq!(Some(&[1,2,3][..]), view1_iter.next());
assert_eq!(Some(&[4,5][..]), view1_iter.next());
assert_eq!(None, view1_iter.next());

impl<'a, S, T, I> ViewMut<'a> for Sparse<S, T, I> where
    S: Set + ViewMut<'a>,
    T: Set + View<'a>,
    I: AsMut<[usize]>, 

type Type = Sparse<S::Type, T::Type, &'a mut [usize]>

fn view_mut(&'a mut self) -> Self::Type

Loading content...