iter_vec 0.1.0

vector of iterator but specialized for std::slice::Iter
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

//! This crate provide vector of iterator
//!
//! This crate aims to ExactSizeIterator for Vec<&\[T\]>
//!
//! usable for vertex and index buffer temporary storage
/*! ```rust
#[test]
fn demo() {
    let content0 = vec![1, 2, 3, 4];
    let content1 = [5, 6, 7, 8];
    let content2 = [9, 0];
    let iter_vec = ExactSizedIterVec::build_from_vec(vec![
        content0.iter(),
        content1.iter(),
        content2.iter(),
    ]);
    let flat: Vec<i32> = iter_vec.copied().collect();
    assert_eq!(vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 0], flat)
}
```
!*/

#[cfg(test)]
mod tests {
    use crate::ExactSizedIterVec;

    #[test]
    fn it_works() {
        let content = vec![1, 2, 3, 4];
        let content2 = vec![5, 6, 7, 8];
        let content3 = vec![9, 0];
        let mut iter_vec = ExactSizedIterVec::new();
        iter_vec.push(&content);
        iter_vec.push(&content2);
        iter_vec.push(&content3);
        let flat: Vec<i32> = iter_vec.copied().collect();
        assert_eq!(vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 0], flat);
    }
    #[test]
    fn demo() {
        let content0 = vec![1, 2, 3, 4];
        let content1 = [5, 6, 7, 8];
        let content2 = [9, 0];
        let iter_vec = ExactSizedIterVec::build_from_vec(vec![
            content0.iter(),
            content1.iter(),
            content2.iter(),
        ]);
        let flat: Vec<i32> = iter_vec.copied().collect();
        assert_eq!(vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 0], flat)
    }
}
#[derive(Debug, Default, Clone)]
pub struct ExactSizedIterVec<'a, T> {
    current_iter: usize,
    iterators: Vec<std::slice::Iter<'a, T>>,
}
impl<'a, T> ExactSizedIterVec<'a, T> {
    pub fn new() -> Self {
        Self {
            current_iter: 0,
            iterators: vec![],
        }
    }
    pub fn build_from_vec(iter: Vec<std::slice::Iter<'a, T>>) -> Self {
        Self {
            current_iter: 0,
            iterators: iter,
        }
    }
    pub fn push(&mut self, element: &'a [T]) {
        self.iterators.push(element.iter())
    }
}
impl<'a, T> Iterator for ExactSizedIterVec<'a, T> {
    type Item = &'a T;

    fn next(&mut self) -> Option<Self::Item> {
        let iter = self.iterators.get_mut(self.current_iter);
        if let Some(iter) = iter {
            let x = iter.next();
            if x.is_none() {
                self.current_iter += 1;
                return self
                    .iterators
                    .get_mut(self.current_iter)
                    .and_then(|x| x.next());
            } else {
                return x;
            }
        }
        None
    }
}

impl<'a, T> ExactSizeIterator for ExactSizedIterVec<'a, T> {
    fn len(&self) -> usize {
        let mut len = 0;
        for iter in self.iterators.iter() {
            len += iter.len();
        }
        len
    }
}