Trait SliceExt

pub trait SliceExt<Token>:
    Native<Token>
    + Slice<Token, W1>
    + Slice<Token, W2>
    + Slice<Token, W4>
    + Slice<Token, W8>
    + Slice<Token, NativeWidth<Self, Token>>
where
    Token: Token,
{
    // Provided methods
    unsafe fn read_unchecked_native(
        &self,
        token: Token,
    ) -> <Self as Slice<Token, <Self as Native<Token>>::Width>>::Vector { ... }
    fn read_native(
        &self,
        token: Token,
    ) -> <Self as Slice<Token, <Self as Native<Token>>::Width>>::Vector { ... }
    fn align_native(
        &self,
        token: Token,
    ) -> (&[<<Self as Slice<Token, <Self as Native<Token>>::Width>>::Vector as Vector>::Scalar], &[<Self as Slice<Token, <Self as Native<Token>>::Width>>::Vector], &[<<Self as Slice<Token, <Self as Native<Token>>::Width>>::Vector as Vector>::Scalar]) { ... }
    fn align_native_mut(
        &mut self,
        token: Token,
    ) -> (&mut [<<Self as Slice<Token, <Self as Native<Token>>::Width>>::Vector as Vector>::Scalar], &mut [<Self as Slice<Token, <Self as Native<Token>>::Width>>::Vector], &mut [<<Self as Slice<Token, <Self as Native<Token>>::Width>>::Vector as Vector>::Scalar]) { ... }
    fn overlapping_native(
        &self,
        token: Token,
    ) -> Overlapping<'_, <Self as Slice<Token, <Self as Native<Token>>::Width>>::Vector> { ... }
    fn overlapping_native_mut(
        &mut self,
        token: Token,
    ) -> OverlappingMut<'_, <Self as Slice<Token, <Self as Native<Token>>::Width>>::Vector> { ... }
    unsafe fn read_unchecked1(
        &self,
        token: Token,
    ) -> <Self as Slice<Token, W1>>::Vector { ... }
    fn read1(&self, token: Token) -> <Self as Slice<Token, W1>>::Vector { ... }
    fn align1(
        &self,
        token: Token,
    ) -> (&[<<Self as Slice<Token, W1>>::Vector as Vector>::Scalar], &[<Self as Slice<Token, W1>>::Vector], &[<<Self as Slice<Token, W1>>::Vector as Vector>::Scalar]) { ... }
    fn align1_mut(
        &mut self,
        token: Token,
    ) -> (&mut [<<Self as Slice<Token, W1>>::Vector as Vector>::Scalar], &mut [<Self as Slice<Token, W1>>::Vector], &mut [<<Self as Slice<Token, W1>>::Vector as Vector>::Scalar]) { ... }
    fn overlapping1(
        &self,
        token: Token,
    ) -> Overlapping<'_, <Self as Slice<Token, W1>>::Vector> { ... }
    fn overlapping1_mut(
        &mut self,
        token: Token,
    ) -> OverlappingMut<'_, <Self as Slice<Token, W1>>::Vector> { ... }
    unsafe fn read_unchecked2(
        &self,
        token: Token,
    ) -> <Self as Slice<Token, W2>>::Vector { ... }
    fn read2(&self, token: Token) -> <Self as Slice<Token, W2>>::Vector { ... }
    fn align2(
        &self,
        token: Token,
    ) -> (&[<<Self as Slice<Token, W2>>::Vector as Vector>::Scalar], &[<Self as Slice<Token, W2>>::Vector], &[<<Self as Slice<Token, W2>>::Vector as Vector>::Scalar]) { ... }
    fn align2_mut(
        &mut self,
        token: Token,
    ) -> (&mut [<<Self as Slice<Token, W2>>::Vector as Vector>::Scalar], &mut [<Self as Slice<Token, W2>>::Vector], &mut [<<Self as Slice<Token, W2>>::Vector as Vector>::Scalar]) { ... }
    fn overlapping2(
        &self,
        token: Token,
    ) -> Overlapping<'_, <Self as Slice<Token, W2>>::Vector> { ... }
    fn overlapping2_mut(
        &mut self,
        token: Token,
    ) -> OverlappingMut<'_, <Self as Slice<Token, W2>>::Vector> { ... }
    unsafe fn read_unchecked4(
        &self,
        token: Token,
    ) -> <Self as Slice<Token, W4>>::Vector { ... }
    fn read4(&self, token: Token) -> <Self as Slice<Token, W4>>::Vector { ... }
    fn align4(
        &self,
        token: Token,
    ) -> (&[<<Self as Slice<Token, W4>>::Vector as Vector>::Scalar], &[<Self as Slice<Token, W4>>::Vector], &[<<Self as Slice<Token, W4>>::Vector as Vector>::Scalar]) { ... }
    fn align4_mut(
        &mut self,
        token: Token,
    ) -> (&mut [<<Self as Slice<Token, W4>>::Vector as Vector>::Scalar], &mut [<Self as Slice<Token, W4>>::Vector], &mut [<<Self as Slice<Token, W4>>::Vector as Vector>::Scalar]) { ... }
    fn overlapping4(
        &self,
        token: Token,
    ) -> Overlapping<'_, <Self as Slice<Token, W4>>::Vector> { ... }
    fn overlapping4_mut(
        &mut self,
        token: Token,
    ) -> OverlappingMut<'_, <Self as Slice<Token, W4>>::Vector> { ... }
    unsafe fn read_unchecked8(
        &self,
        token: Token,
    ) -> <Self as Slice<Token, W8>>::Vector { ... }
    fn read8(&self, token: Token) -> <Self as Slice<Token, W8>>::Vector { ... }
    fn align8(
        &self,
        token: Token,
    ) -> (&[<<Self as Slice<Token, W8>>::Vector as Vector>::Scalar], &[<Self as Slice<Token, W8>>::Vector], &[<<Self as Slice<Token, W8>>::Vector as Vector>::Scalar]) { ... }
    fn align8_mut(
        &mut self,
        token: Token,
    ) -> (&mut [<<Self as Slice<Token, W8>>::Vector as Vector>::Scalar], &mut [<Self as Slice<Token, W8>>::Vector], &mut [<<Self as Slice<Token, W8>>::Vector as Vector>::Scalar]) { ... }
    fn overlapping8(
        &self,
        token: Token,
    ) -> Overlapping<'_, <Self as Slice<Token, W8>>::Vector> { ... }
    fn overlapping8_mut(
        &mut self,
        token: Token,
    ) -> OverlappingMut<'_, <Self as Slice<Token, W8>>::Vector> { ... }
}

A slice of scalars, supporting all vector widths.

Provided Methods

unsafe fn read_unchecked_native( &self, token: Token, ) -> <Self as Slice<Token, <Self as Native<Token>>::Width>>::Vector

Read a vector with the native number of lanes from a slice without checking the length.

See read_unchecked.

fn read_native( &self, token: Token, ) -> <Self as Slice<Token, <Self as Native<Token>>::Width>>::Vector

Read a vector with the native number of lanes from a slice.

See read.

fn align_native( &self, token: Token, ) -> (&[<<Self as Slice<Token, <Self as Native<Token>>::Width>>::Vector as Vector>::Scalar], &[<Self as Slice<Token, <Self as Native<Token>>::Width>>::Vector], &[<<Self as Slice<Token, <Self as Native<Token>>::Width>>::Vector as Vector>::Scalar])

Align a slice of scalars to vectors with the native number of lanes .

See align.

fn align_native_mut( &mut self, token: Token, ) -> (&mut [<<Self as Slice<Token, <Self as Native<Token>>::Width>>::Vector as Vector>::Scalar], &mut [<Self as Slice<Token, <Self as Native<Token>>::Width>>::Vector], &mut [<<Self as Slice<Token, <Self as Native<Token>>::Width>>::Vector as Vector>::Scalar])

Align a slice of scalars to vectors with the native number of lanes .

See align_mut.

fn overlapping_native( &self, token: Token, ) -> Overlapping<'_, <Self as Slice<Token, <Self as Native<Token>>::Width>>::Vector>

Create a slice of overlapping vectors of the native number of lanes from a slice of scalars.

See overlapping.

fn overlapping_native_mut( &mut self, token: Token, ) -> OverlappingMut<'_, <Self as Slice<Token, <Self as Native<Token>>::Width>>::Vector>

Create a mutable slice of overlapping vectors of the native number of lanes from a slice of scalars.

See overlapping_mut.

unsafe fn read_unchecked1( &self, token: Token, ) -> <Self as Slice<Token, W1>>::Vector

Read a vector with 1 lane from a slice without checking the length.

See read_unchecked.

fn read1(&self, token: Token) -> <Self as Slice<Token, W1>>::Vector

Read a vector with 1 lane from a slice.

See read.

fn align1( &self, token: Token, ) -> (&[<<Self as Slice<Token, W1>>::Vector as Vector>::Scalar], &[<Self as Slice<Token, W1>>::Vector], &[<<Self as Slice<Token, W1>>::Vector as Vector>::Scalar])

Align a slice of scalars to vectors with 1 lane .

See align.

fn align1_mut( &mut self, token: Token, ) -> (&mut [<<Self as Slice<Token, W1>>::Vector as Vector>::Scalar], &mut [<Self as Slice<Token, W1>>::Vector], &mut [<<Self as Slice<Token, W1>>::Vector as Vector>::Scalar])

Align a slice of scalars to vectors with 1 lane .

See align_mut.

fn overlapping1( &self, token: Token, ) -> Overlapping<'_, <Self as Slice<Token, W1>>::Vector>

Create a slice of overlapping vectors of 1 lane from a slice of scalars.

See overlapping.

fn overlapping1_mut( &mut self, token: Token, ) -> OverlappingMut<'_, <Self as Slice<Token, W1>>::Vector>

Create a mutable slice of overlapping vectors of 1 lane from a slice of scalars.

See overlapping_mut.

unsafe fn read_unchecked2( &self, token: Token, ) -> <Self as Slice<Token, W2>>::Vector

Read a vector with 2 lanes from a slice without checking the length.

See read_unchecked.

fn read2(&self, token: Token) -> <Self as Slice<Token, W2>>::Vector

Read a vector with 2 lanes from a slice.

See read.

fn align2( &self, token: Token, ) -> (&[<<Self as Slice<Token, W2>>::Vector as Vector>::Scalar], &[<Self as Slice<Token, W2>>::Vector], &[<<Self as Slice<Token, W2>>::Vector as Vector>::Scalar])

Align a slice of scalars to vectors with 2 lanes .

See align.

fn align2_mut( &mut self, token: Token, ) -> (&mut [<<Self as Slice<Token, W2>>::Vector as Vector>::Scalar], &mut [<Self as Slice<Token, W2>>::Vector], &mut [<<Self as Slice<Token, W2>>::Vector as Vector>::Scalar])

Align a slice of scalars to vectors with 2 lanes .

See align_mut.

fn overlapping2( &self, token: Token, ) -> Overlapping<'_, <Self as Slice<Token, W2>>::Vector>

Create a slice of overlapping vectors of 2 lanes from a slice of scalars.

See overlapping.

fn overlapping2_mut( &mut self, token: Token, ) -> OverlappingMut<'_, <Self as Slice<Token, W2>>::Vector>

Create a mutable slice of overlapping vectors of 2 lanes from a slice of scalars.

See overlapping_mut.

unsafe fn read_unchecked4( &self, token: Token, ) -> <Self as Slice<Token, W4>>::Vector

Read a vector with 4 lanes from a slice without checking the length.

See read_unchecked.

fn read4(&self, token: Token) -> <Self as Slice<Token, W4>>::Vector

Read a vector with 4 lanes from a slice.

See read.

fn align4( &self, token: Token, ) -> (&[<<Self as Slice<Token, W4>>::Vector as Vector>::Scalar], &[<Self as Slice<Token, W4>>::Vector], &[<<Self as Slice<Token, W4>>::Vector as Vector>::Scalar])

Align a slice of scalars to vectors with 4 lanes .

See align.

fn align4_mut( &mut self, token: Token, ) -> (&mut [<<Self as Slice<Token, W4>>::Vector as Vector>::Scalar], &mut [<Self as Slice<Token, W4>>::Vector], &mut [<<Self as Slice<Token, W4>>::Vector as Vector>::Scalar])

Align a slice of scalars to vectors with 4 lanes .

See align_mut.

fn overlapping4( &self, token: Token, ) -> Overlapping<'_, <Self as Slice<Token, W4>>::Vector>

Create a slice of overlapping vectors of 4 lanes from a slice of scalars.

See overlapping.

fn overlapping4_mut( &mut self, token: Token, ) -> OverlappingMut<'_, <Self as Slice<Token, W4>>::Vector>

Create a mutable slice of overlapping vectors of 4 lanes from a slice of scalars.

See overlapping_mut.

unsafe fn read_unchecked8( &self, token: Token, ) -> <Self as Slice<Token, W8>>::Vector

Read a vector with 8 lanes from a slice without checking the length.

See read_unchecked.

fn read8(&self, token: Token) -> <Self as Slice<Token, W8>>::Vector

Read a vector with 8 lanes from a slice.

See read.

fn align8( &self, token: Token, ) -> (&[<<Self as Slice<Token, W8>>::Vector as Vector>::Scalar], &[<Self as Slice<Token, W8>>::Vector], &[<<Self as Slice<Token, W8>>::Vector as Vector>::Scalar])

Align a slice of scalars to vectors with 8 lanes .

See align.

fn align8_mut( &mut self, token: Token, ) -> (&mut [<<Self as Slice<Token, W8>>::Vector as Vector>::Scalar], &mut [<Self as Slice<Token, W8>>::Vector], &mut [<<Self as Slice<Token, W8>>::Vector as Vector>::Scalar])

Align a slice of scalars to vectors with 8 lanes .

See align_mut.

fn overlapping8( &self, token: Token, ) -> Overlapping<'_, <Self as Slice<Token, W8>>::Vector>

Create a slice of overlapping vectors of 8 lanes from a slice of scalars.

See overlapping.

fn overlapping8_mut( &mut self, token: Token, ) -> OverlappingMut<'_, <Self as Slice<Token, W8>>::Vector>

Create a mutable slice of overlapping vectors of 8 lanes from a slice of scalars.

See overlapping_mut.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<T, Token> SliceExt<Token> for T

where T: ?Sized + Native<Token> + Slice<Token, W1> + Slice<Token, W2> + Slice<Token, W4> + Slice<Token, W8> + Slice<Token, NativeWidth<Self, Token>>, Token: Token,