Struct RefMutIter 

pub struct RefMutIter<'a, I> { /* private fields */ }

Iterator from RefMut.

Examples

let samples = vec![1, 2, 3];
let cell = RefCell::new(samples.clone());
let mut iter = RefMutIter::new(cell.borrow_mut(), |x| x.iter_mut());
while let Some(item) = iter.next_mut() {
    *item += 1;
}
drop(iter);

let results = cell.into_inner();
let expecteds = vec![2, 3, 4];
assert_eq!(results, expecteds);

Implementations

impl<'a, I> RefMutIter<'a, I>

pub fn new<S, F>(src: RefMut<'a, S>, f: F) -> Self

where S: Any, F: Fn(&'a mut S) -> I,

Creates a new value.

Trait Implementations

impl<'a, I: Debug> Debug for RefMutIter<'a, I>

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

Formats the value using the given formatter.

impl<I> ExactSizeRefIterator for RefMutIter<'_, I>

where Self: RefIterator, I: ExactSizeIterator,

fn len(&self) -> usize

Returns the exact remaining length of the iterator.

fn is_empty(&self) -> bool

Returns true if the iterator is empty.

impl<'a, I, T> RefIterator for RefMutIter<'a, I>

where I: Iterator<Item = &'a mut T>, T: 'a,

type Item = T

The type of the elements being iterated over.

fn next(&mut self) -> Option<&Self::Item>

Advances the iterator and returns the next value.

fn icloned(self) -> ICloned<Self>

where Self: Sized, Self::Item: Clone,

Creates an iterator that clone dynamic borrowing elements.

fn iflat_map<'call, F>(self, f: F) -> IFlatMap<'call, Self, F>

where Self: Sized, F: for<'a> FnIFlatMap<&'a Self::Item>,

Creates an iterator that flattens mapped each dynamic borrowing iterators.

fn imap<B, F>(self, f: F) -> IMap<Self, F>

where Self: Sized, F: FnMut(&Self::Item) -> B,

Creates an iterator that maps dynamic borrowing elements.

fn eq<I>(self, other: I) -> bool

where Self: Sized, Self::Item: PartialEq<I::Item>, I: IntoRefIterator,

Determines if the elements of this is equal to those of another.

impl<I> RefIteratorBase for RefMutIter<'_, I>

where I: Iterator,

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

Returns the bounds on the remaining length of the iterator.

impl<'a, I, K, V> RefKvIterator for RefMutIter<'a, I>

where I: Iterator<Item = (&'a K, &'a mut V)>, K: 'a, V: 'a,

type K = K

The key type of the elements being iterated over.

type V = V

The value type of the elements being iterated over.

fn next(&mut self) -> Option<(&Self::K, &Self::V)>

Advances the iterator and returns the next key-value.

fn imap<B, F>(self, f: F) -> KvIMap<Self, F>

where Self: Sized, F: FnMut(&Self::K, &Self::V) -> B,

Creates an iterator that maps dynamic borrowing elements.

impl<'a, I, T> RefMutIterator for RefMutIter<'a, I>

where I: Iterator<Item = &'a mut T>, T: 'a,

fn next_mut(&mut self) -> Option<&mut Self::Item>

Advances the iterator and returns the next mutable value.

impl<'a, I, K, V> RefMutKvIterator for RefMutIter<'a, I>

where I: Iterator<Item = (&'a K, &'a mut V)>, K: 'a, V: 'a,

fn next_mut(&mut self) -> Option<(&Self::K, &mut Self::V)>

Advances the iterator and returns the next mutable key-value.