moirai-iter 0.7.0

Parallel and async iterator combinators for Moirai concurrency library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

//! FlatMap iterator adapter.

/// Iterator adapter that flattens nested iterators.
#[derive(Clone)]
pub struct FlatMap<I, U, F> {
    iter: I,
    f: F,
    frontiter: Option<U>,
    backiter: Option<U>,
}

impl<I, U, F> FlatMap<I, U, F> {
    /// Creates a new `FlatMap` adapter.
    #[inline]
    pub fn new(iter: I, f: F) -> Self {
        FlatMap {
            iter,
            f,
            frontiter: None,
            backiter: None,
        }
    }
}

impl<I, U, F> Iterator for FlatMap<I, U, F>
where
    I: Iterator,
    U: Iterator,
    F: FnMut(I::Item) -> U,
{
    type Item = U::Item;

    #[inline]
    fn next(&mut self) -> Option<U::Item> {
        loop {
            if let Some(ref mut inner) = self.frontiter
                && let Some(item) = inner.next()
            {
                return Some(item);
            }
            match self.iter.next() {
                None => return self.backiter.as_mut()?.next(),
                Some(item) => self.frontiter = Some((self.f)(item)),
            }
        }
    }

    #[inline]
    fn size_hint(&self) -> (usize, Option<usize>) {
        let (flo, fhi) = self
            .frontiter
            .as_ref()
            .map_or((0, Some(0)), |it| it.size_hint());
        let (blo, bhi) = self
            .backiter
            .as_ref()
            .map_or((0, Some(0)), |it| it.size_hint());
        let lo = flo.saturating_add(blo);
        match (self.iter.size_hint(), fhi, bhi) {
            ((0, Some(0)), Some(fhi), Some(bhi)) => (lo, fhi.checked_add(bhi)),
            _ => (lo, None),
        }
    }
}