Struct fixedvec::IterMut

pub struct IterMut<'a, T> where
    T: 'a,  { /* fields omitted */ }

Mutable slice iterator.

This struct is created by the iter_mut method on slices.

Examples

Basic usage:

// First, we declare a type which has `iter_mut` method to get the `IterMut`
// struct (&[usize here]):
let mut slice = &mut [1, 2, 3];

// Then, we iterate over it and increment each element value:
for element in slice.iter_mut() {
    *element += 1;
}

// We now have "[2, 3, 4]":
println!("{:?}", slice);

Methods

impl<'a, T> IterMut<'a, T>

fn into_slice(self) -> &'a mut [T]

View the underlying data as a subslice of the original data.

To avoid creating &mut references that alias, this is forced to consume the iterator. Consider using the Slice and SliceMut implementations for obtaining slices with more restricted lifetimes that do not consume the iterator.

Examples

Basic usage:

// First, we declare a type which has `iter_mut` method to get the `IterMut`
// struct (&[usize here]):
let mut slice = &mut [1, 2, 3];

{
    // Then, we get the iterator:
    let mut iter = slice.iter_mut();
    // We move to next element:
    iter.next();
    // So if we print what `into_slice` method returns here, we have "[2, 3]":
    println!("{:?}", iter.into_slice());
}

// Now let's modify a value of the slice:
{
    // First we get back the iterator:
    let mut iter = slice.iter_mut();
    // We change the value of the first element of the slice returned by the `next` method:
    *iter.next().unwrap() += 1;
}
// Now slice is "[2, 2, 3]":
println!("{:?}", slice);

Trait Implementations

impl<'a, T> Iterator for IterMut<'a, T>

type Item = &'a mut T

fn next(&mut self) -> Option<&'a mut T>

fn size_hint(&self) -> (usize, Option<usize>)

fn count(self) -> usize

fn nth(&mut self, n: usize) -> Option<&'a mut T>

fn last(self) -> Option<&'a mut T>

fn all<F>(&mut self, predicate: F) -> bool where
    F: FnMut(<IterMut<'a, T> as Iterator>::Item) -> bool, 

fn any<F>(&mut self, predicate: F) -> bool where
    F: FnMut(<IterMut<'a, T> as Iterator>::Item) -> bool, 

fn find<F>(
    &mut self,
    predicate: F
) -> Option<<IterMut<'a, T> as Iterator>::Item> where
    F: FnMut(&<IterMut<'a, T> as Iterator>::Item) -> bool, 

fn position<F>(&mut self, predicate: F) -> Option<usize> where
    F: FnMut(<IterMut<'a, T> as Iterator>::Item) -> bool, 

fn rposition<F>(&mut self, predicate: F) -> Option<usize> where
    F: FnMut(<IterMut<'a, T> as Iterator>::Item) -> bool, 

impl<'a, T> FusedIterator for IterMut<'a, T>

impl<'a, T> ExactSizeIterator for IterMut<'a, T>

fn is_empty(&self) -> bool

impl<'a, T> Send for IterMut<'a, T> where
    T: Send, 

impl<'a, T> DoubleEndedIterator for IterMut<'a, T>

fn next_back(&mut self) -> Option<&'a mut T>

fn rfind<F>(
    &mut self,
    predicate: F
) -> Option<<IterMut<'a, T> as Iterator>::Item> where
    F: FnMut(&<IterMut<'a, T> as Iterator>::Item) -> bool, 

impl<'a, T> TrustedLen for IterMut<'a, T>

impl<'a, T> Sync for IterMut<'a, T> where
    T: Sync, 

impl<'a, T> Debug for IterMut<'a, T> where
    T: 'a + Debug, 

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

Formats the value using the given formatter.