Struct slipstream::iterators::MutProxy

pub struct MutProxy<'a, B, V> where
    V: AsRef<[B]>,
    B: Copy,  { /* fields omitted */ }

A proxy object for iterating over mutable slices.

For technical reasons (mostly alignment and padding), it’s not possible to return a simple reference. This type is returned instead and it can be used to both read and write the vectors a slice is turned into.

Note that the data are written in the destructor. Usually, this should not matter, but if you forget, the changes will be lost (this is meant as a warning, not as a way to implement poor-man’s transactions).

Trait Implementations

impl<'a, B: Debug, V: Debug> Debug for MutProxy<'a, B, V> where
    V: AsRef<[B]>,
    B: Copy, 

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

Formats the value using the given formatter.

impl<B, V> Deref for MutProxy<'_, B, V> where
    V: AsRef<[B]>,
    B: Copy, 

type Target = V

The resulting type after dereferencing.

fn deref(&self) -> &V

Dereferences the value.

impl<B, V> DerefMut for MutProxy<'_, B, V> where
    V: AsRef<[B]>,
    B: Copy, 

fn deref_mut(&mut self) -> &mut V

Mutably dereferences the value.

impl<B, V> Drop for MutProxy<'_, B, V> where
    V: AsRef<[B]>,
    B: Copy, 

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, A: Align, B: Repr, const S: usize> Vectorizable<MutProxy<'a, B, Vector<A, B, S>>> for &'a mut [B]

type Vectorizer = WriteVectorizer<'a, A, B, S>

An internal type managing the splitting into vectors.

type Padding = Vector<A, B, S>

The input type provided by user to fill in the padding/uneven end.

fn create(
    self,
    pad: Option<Vector<A, B, S>>
) -> (Self::Vectorizer, usize, Option<MutProxy<'a, B, Vector<A, B, S>>>)

Internal method to create the vectorizer and kick of the iteration.

fn vectorize(self) -> VectorizedIter<Self::Vectorizer, (), V>

Vectorize a slice or composite of slices

fn vectorize_pad(
    self,
    pad: Self::Padding
) -> VectorizedIter<Self::Vectorizer, Option<V>, V>

Vectorizes a slice or composite of slices, padding the odd end if needed.