vec_iter/
lib.rs

1#![no_std]
2#![doc = include_str!("../README.md")]
3
4extern crate alloc;
5
6use core::ops::{Deref, DerefMut};
7
8use alloc::{vec, vec::Vec};
9
10/// Create from [`IterVecIterExt::vec_iter`]
11#[derive(Debug, Clone)]
12pub struct VecIter<I: Iterator> {
13    iter: I,
14    collected: Vec<I::Item>,
15}
16
17impl<I: Iterator> Deref for VecIter<I> {
18    type Target = [I::Item];
19
20    fn deref(&self) -> &Self::Target {
21        &self.collected
22    }
23}
24
25impl<I: Iterator> DerefMut for VecIter<I> {
26    fn deref_mut(&mut self) -> &mut Self::Target {
27        &mut self.collected
28    }
29}
30
31impl<I: Iterator> Iterator for VecIter<I>
32where I::Item: Clone,
33{
34    type Item = I::Item;
35
36    fn next(&mut self) -> Option<Self::Item> {
37        let elem = self.iter.next()?;
38        self.init_capacity_push(elem.clone());
39        Some(elem)
40    }
41
42    fn nth(&mut self, n: usize) -> Option<Self::Item> {
43        let elem = self.iter.next()?;
44        self.init_capacity_push(elem);
45        for _ in 1..n {
46            self.collected.push(self.iter.next()?);
47        }
48        self.next()
49    }
50
51    fn size_hint(&self) -> (usize, Option<usize>) {
52        let (lo, hi) = self.iter.size_hint();
53        (lo+self.collected_len(), hi.map(|hi| hi+self.collected_len()))
54    }
55
56    fn fold<B, F>(self, init: B, f: F) -> B
57    where Self: Sized,
58          F: FnMut(B, Self::Item) -> B,
59    {
60        self.collected.into_iter().chain(self.iter).fold(init, f)
61    }
62}
63
64impl<I: Iterator> VecIter<I>
65where I::Item: Clone,
66{
67    fn init_capacity(&mut self) {
68        if self.collected_len() == 0 {
69            self.collected.reserve(self.size_hint().0);
70        }
71    }
72
73    fn init_capacity_push(&mut self, value: I::Item) {
74        if self.collected_len() == 0 {
75            self.collected.reserve(self.size_hint().0+1);
76        }
77        self.collected.push(value);
78    }
79
80    fn require(&mut self, i: usize) -> Option<&mut I::Item> {
81        self.init_capacity();
82        let n = i.saturating_sub(self.collected_len())+1;
83        self.collected.extend(self.iter.by_ref().take(n));
84        self.collected.get_mut(i)
85    }
86
87    #[inline]
88    pub fn collected_len(&self) -> usize {
89        self.collected.len()
90    }
91
92    /// Collect to `i+1`, and index `i`
93    pub fn get_req(&mut self, i: usize) -> Option<&I::Item> {
94        self.require(i).map(|value| &*value)
95    }
96
97    /// Collect to `i+1`, and index `i`
98    pub fn get_req_mut(&mut self, i: usize) -> Option<&mut I::Item> {
99        self.require(i)
100    }
101
102    /// Collect to `i+1`, and index `i`
103    pub fn get_req_cloned(&mut self, i: usize) -> Option<I::Item> {
104        self.require(i).cloned()
105    }
106
107    /// Collect all elements, and into inner collected buffer
108    pub fn into_all_collected(mut self) -> Vec<I::Item> {
109        self.collected.extend(self.iter);
110        self.collected
111    }
112}
113
114impl<I: Iterator + Default> Default for VecIter<I> {
115    fn default() -> Self {
116        Self {
117            iter: I::default(),
118            collected: vec![],
119        }
120    }
121}
122
123#[doc = include_str!("../README.md")]
124pub trait IterVecIterExt: Iterator + Sized {
125    /// Create a [`VecIter`]
126    ///
127    /// # Examples
128    /// ```
129    /// # use vec_iter::IterVecIterExt;
130    /// let mut iter = [0, 1, 2, 3, 4].into_iter().vec_iter();
131    ///
132    /// assert_eq!(iter.next(), Some(0));
133    /// assert_eq!(*iter, [0]);
134    /// assert_eq!(iter.nth(1), Some(2));
135    /// assert_eq!(*iter, [0, 1, 2]);
136    /// assert_eq!(iter.get_req(3), Some(&3));
137    /// assert_eq!(*iter, [0, 1, 2, 3]);
138    /// assert_eq!(iter.into_all_collected(), [0, 1, 2, 3, 4]);
139    /// ```
140    fn vec_iter(self) -> VecIter<Self> {
141        VecIter { iter: self, collected: vec![] }
142    }
143}
144impl<I: Iterator> IterVecIterExt for I { }
145
146#[cfg(test)]
147mod tests {
148    use super::*;
149
150    #[test]
151    fn basic_each() {
152        assert_eq!((0..5).vec_iter().collect::<Vec<_>>(), vec![0, 1, 2, 3, 4]);
153        assert_eq!((0..0).vec_iter().collect::<Vec<_>>(), vec![]);
154    }
155
156    #[test]
157    fn capacity() {
158        let mut iter = (0..5).vec_iter();
159        assert_eq!(iter.collected.capacity(), 0);
160        assert_eq!(iter.next(), Some(0));
161        assert_eq!(iter.collected.capacity(), 5);
162        assert_eq!(iter.collected_len(), 1);
163    }
164
165    #[test]
166    fn nth() {
167        let mut iter = (0..5).vec_iter();
168        assert_eq!(iter.collected.capacity(), 0);
169        assert_eq!(iter.nth(2), Some(2));
170        assert_eq!(iter.collected.capacity(), 5);
171        assert_eq!(*iter, [0, 1, 2]);
172        assert_eq!(iter.next(), Some(3));
173    }
174
175    #[test]
176    fn into_all_collected() {
177        let mut iter = (0..5).vec_iter();
178        assert_eq!(iter.collected.capacity(), 0);
179        assert_eq!(iter.next(), Some(0));
180        assert_eq!(iter.collected.capacity(), 5);
181        assert_eq!(iter.collected_len(), 1);
182        assert_eq!(iter.into_all_collected(), vec![0, 1, 2, 3, 4]);
183    }
184
185    #[test]
186    fn get_req() {
187        let mut iter = (0..5).vec_iter();
188        assert_eq!(iter.collected.capacity(), 0);
189        assert_eq!(iter.get_req_cloned(2), Some(2));
190        assert_eq!(iter.collected.capacity(), 5);
191        assert_eq!(iter.collected_len(), 3);
192        assert_eq!(iter.into_all_collected(), vec![0, 1, 2, 3, 4]);
193    }
194}
vec_iter/lib.rs

vec_iter/
lib.rs
