Trait rerun::external::ndarray::MultiSliceArg

pub trait MultiSliceArg<'a, A, D>
where
    A: 'a,
    D: Dimension,
{
    type Output;

    // Required method
    fn multi_slice_move(
        &self,
        view: ArrayBase<ViewRepr<&'a mut A>, D>
    ) -> Self::Output;
}

Slicing information describing multiple mutable, disjoint slices.

It’s unfortunate that we need 'a and A to be parameters of the trait, but they’re necessary until Rust supports generic associated types.

Required Associated Types

type Output

The type of the slices created by .multi_slice_move().

Required Methods

fn multi_slice_move( &self, view: ArrayBase<ViewRepr<&'a mut A>, D> ) -> Self::Output

Split the view into multiple disjoint slices.

Panics if performing any individual slice panics or if the slices are not disjoint (i.e. if they intersect).

Implementations on Foreign Types

impl<'a, A, D> MultiSliceArg<'a, A, D> for ()

where A: 'a, D: Dimension,

type Output = ()

fn multi_slice_move( &self, _view: ArrayBase<ViewRepr<&'a mut A>, D> ) -> <() as MultiSliceArg<'a, A, D>>::Output

impl<'a, A, D, I0> MultiSliceArg<'a, A, D> for (I0,)

where A: 'a, D: Dimension, I0: SliceArg<D>,

type Output = (ArrayBase<ViewRepr<&'a mut A>, <I0 as SliceArg<D>>::OutDim>,)

fn multi_slice_move( &self, view: ArrayBase<ViewRepr<&'a mut A>, D> ) -> <(I0,) as MultiSliceArg<'a, A, D>>::Output

impl<'a, A, D, I0, I1> MultiSliceArg<'a, A, D> for (I0, I1)

where A: 'a, D: Dimension, I0: SliceArg<D>, I1: SliceArg<D>,

type Output = (ArrayBase<ViewRepr<&'a mut A>, <I0 as SliceArg<D>>::OutDim>, ArrayBase<ViewRepr<&'a mut A>, <I1 as SliceArg<D>>::OutDim>)

fn multi_slice_move( &self, view: ArrayBase<ViewRepr<&'a mut A>, D> ) -> <(I0, I1) as MultiSliceArg<'a, A, D>>::Output

impl<'a, A, D, I0, I1, I2> MultiSliceArg<'a, A, D> for (I0, I1, I2)

where A: 'a, D: Dimension, I0: SliceArg<D>, I1: SliceArg<D>, I2: SliceArg<D>,

type Output = (ArrayBase<ViewRepr<&'a mut A>, <I0 as SliceArg<D>>::OutDim>, ArrayBase<ViewRepr<&'a mut A>, <I1 as SliceArg<D>>::OutDim>, ArrayBase<ViewRepr<&'a mut A>, <I2 as SliceArg<D>>::OutDim>)

fn multi_slice_move( &self, view: ArrayBase<ViewRepr<&'a mut A>, D> ) -> <(I0, I1, I2) as MultiSliceArg<'a, A, D>>::Output

impl<'a, A, D, I0, I1, I2, I3> MultiSliceArg<'a, A, D> for (I0, I1, I2, I3)

where A: 'a, D: Dimension, I0: SliceArg<D>, I1: SliceArg<D>, I2: SliceArg<D>, I3: SliceArg<D>,

type Output = (ArrayBase<ViewRepr<&'a mut A>, <I0 as SliceArg<D>>::OutDim>, ArrayBase<ViewRepr<&'a mut A>, <I1 as SliceArg<D>>::OutDim>, ArrayBase<ViewRepr<&'a mut A>, <I2 as SliceArg<D>>::OutDim>, ArrayBase<ViewRepr<&'a mut A>, <I3 as SliceArg<D>>::OutDim>)

fn multi_slice_move( &self, view: ArrayBase<ViewRepr<&'a mut A>, D> ) -> <(I0, I1, I2, I3) as MultiSliceArg<'a, A, D>>::Output

impl<'a, A, D, I0, I1, I2, I3, I4> MultiSliceArg<'a, A, D> for (I0, I1, I2, I3, I4)

where A: 'a, D: Dimension, I0: SliceArg<D>, I1: SliceArg<D>, I2: SliceArg<D>, I3: SliceArg<D>, I4: SliceArg<D>,

type Output = (ArrayBase<ViewRepr<&'a mut A>, <I0 as SliceArg<D>>::OutDim>, ArrayBase<ViewRepr<&'a mut A>, <I1 as SliceArg<D>>::OutDim>, ArrayBase<ViewRepr<&'a mut A>, <I2 as SliceArg<D>>::OutDim>, ArrayBase<ViewRepr<&'a mut A>, <I3 as SliceArg<D>>::OutDim>, ArrayBase<ViewRepr<&'a mut A>, <I4 as SliceArg<D>>::OutDim>)

fn multi_slice_move( &self, view: ArrayBase<ViewRepr<&'a mut A>, D> ) -> <(I0, I1, I2, I3, I4) as MultiSliceArg<'a, A, D>>::Output

impl<'a, A, D, I0, I1, I2, I3, I4, I5> MultiSliceArg<'a, A, D> for (I0, I1, I2, I3, I4, I5)

where A: 'a, D: Dimension, I0: SliceArg<D>, I1: SliceArg<D>, I2: SliceArg<D>, I3: SliceArg<D>, I4: SliceArg<D>, I5: SliceArg<D>,

type Output = (ArrayBase<ViewRepr<&'a mut A>, <I0 as SliceArg<D>>::OutDim>, ArrayBase<ViewRepr<&'a mut A>, <I1 as SliceArg<D>>::OutDim>, ArrayBase<ViewRepr<&'a mut A>, <I2 as SliceArg<D>>::OutDim>, ArrayBase<ViewRepr<&'a mut A>, <I3 as SliceArg<D>>::OutDim>, ArrayBase<ViewRepr<&'a mut A>, <I4 as SliceArg<D>>::OutDim>, ArrayBase<ViewRepr<&'a mut A>, <I5 as SliceArg<D>>::OutDim>)

fn multi_slice_move( &self, view: ArrayBase<ViewRepr<&'a mut A>, D> ) -> <(I0, I1, I2, I3, I4, I5) as MultiSliceArg<'a, A, D>>::Output

impl<'a, A, D, T> MultiSliceArg<'a, A, D> for &T

where A: 'a, D: Dimension, T: MultiSliceArg<'a, A, D>,

type Output = <T as MultiSliceArg<'a, A, D>>::Output

fn multi_slice_move( &self, view: ArrayBase<ViewRepr<&'a mut A>, D> ) -> <&T as MultiSliceArg<'a, A, D>>::Output

Implementors