ref_iter 0.4.2

Dynamic borrowing iterator.
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

//! Provider of [`IFlatMap`].

use crate::closures::{FnIFlatMap, FnIFlatMapItem, FnIFlatMapIter};
use crate::prelude::*;
use crate::util::msg;
use core::fmt::{self, Debug, Formatter};
use core::mem;

/// An iterator that flatten maped each dynamic borrowing iterators.
///
/// This struct is created by [`RefIterator::iflat_map`].
#[must_use = msg::iter_must_use!()]
pub struct IFlatMap<'this, I, F>
where
    I: RefIterator,
    F: for<'x> FnIFlatMap<&'x I::Item>,
{
    /// Base iterator.
    iter: I,
    /// Sub iterator.
    sub_iter: Option<FnIFlatMapIter<F, &'this I::Item>>,
    /// Closure for each item mapping.
    f: F,
}

impl<'this, I, F> IFlatMap<'this, I, F>
where
    I: RefIterator,
    F: for<'x> FnIFlatMap<&'x I::Item>,
{
    /// Creates a new value.
    pub(crate) fn new(iter: I, f: F) -> Self {
        let sub_iter = None;
        Self { iter, sub_iter, f }
    }

    /// Advance base iterator and returns next sub iterator.
    fn next_sub_iter(&mut self) -> Option<FnIFlatMapIter<F, &'this I::Item>> {
        let ret = (self.f)(self.iter.next()?).into_iter();
        Some(unsafe { Self::adjust_sub_iter(ret) })
    }

    /// Adjust sub iterator lifetime.
    unsafe fn adjust_sub_iter<'a>(
        x: FnIFlatMapIter<F, &'_ I::Item>,
    ) -> FnIFlatMapIter<F, &'a I::Item> {
        #[rustfmt::skip]
        return unsafe {
            mem::transmute::<
                FnIFlatMapIter<F, &'_ _>,
                FnIFlatMapIter<F, &'a _>
            >(x)
        };
    }
}

impl<'this, I, F> Clone for IFlatMap<'this, I, F>
where
    I: RefIterator + Clone,
    F: for<'x> FnIFlatMap<&'x I::Item> + Clone,
    FnIFlatMapIter<F, &'this I::Item>: Clone,
{
    fn clone(&self) -> Self {
        Self {
            iter: self.iter.clone(),
            sub_iter: self.sub_iter.clone(),
            f: self.f.clone(),
        }
    }
}

impl<'this, I, F> Debug for IFlatMap<'this, I, F>
where
    I: RefIterator + Debug,
    F: for<'x> FnIFlatMap<&'x I::Item> + Debug,
    FnIFlatMapIter<F, &'this I::Item>: Debug,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        f.debug_struct("RefFlatMap")
            .field("iter", &self.iter)
            .field("sub_iter", &self.sub_iter)
            .field("f", &self.f)
            .finish()
    }
}

impl<'this, I, F> Iterator for IFlatMap<'this, I, F>
where
    I: RefIterator,
    F: for<'x> FnIFlatMap<&'x I::Item>,
{
    type Item = FnIFlatMapItem<F, &'this I::Item>;

    fn next(&mut self) -> Option<Self::Item> {
        if self.sub_iter.is_none() {
            self.sub_iter = self.next_sub_iter();
        }

        loop {
            let item = self.sub_iter.as_mut().unwrap().next();
            if item.is_some() {
                return item;
            }

            self.sub_iter = Some(self.next_sub_iter()?);
        }
    }
}