#![no_std]
pub struct PutBackPeekMore<Iter, const BUFSIZE: usize>
where
Iter: Iterator,
{
pub(crate) iter: Iter,
pub(crate) peek: [Option<Iter::Item>; BUFSIZE],
pub(crate) fizz: usize,
}
impl<Iter, const BUFSIZE: usize> PutBackPeekMore<Iter, BUFSIZE>
where
Iter: Iterator,
{
pub fn new(mut iter: Iter) -> Self {
let peek: [Option<Iter::Item>; BUFSIZE] = [(); BUFSIZE].map(|_| iter.next());
Self {
iter,
peek,
fizz: 0,
}
}
pub fn peek(&mut self) -> &Option<Iter::Item> {
self.demand(1);
&self.peek[self.fizz]
}
pub fn peek_value(&mut self, amount: usize) -> &[Option<Iter::Item>] {
self.demand(amount);
&self.peek[self.fizz..self.fizz + amount]
}
pub(crate) fn demand(&mut self, val: usize) {
if self.fizz + val > self.peek.len() {
self.write_over_start();
}
}
pub(crate) fn write_over_val(&mut self, val: usize) {
for i in val..(BUFSIZE - self.fizz) {
self.peek[i] = self.peek[self.fizz + i].take();
}
for i in (BUFSIZE - self.fizz)..BUFSIZE {
self.peek[i] = self.iter.next();
}
self.fizz = 0;
}
pub(crate) fn write_over_start(&mut self) {
self.write_over_val(0);
}
pub fn put_back(&mut self, val: Option<Iter::Item>) {
if self.fizz > 0 {
self.peek[self.fizz - 1] = val;
self.fizz -= 1;
} else {
self.write_over_val(1);
self.put_back(val);
self.fizz -= 1;
}
}
}
impl<Iter, const PEEK: usize> core::fmt::Debug for PutBackPeekMore<Iter, PEEK>
where
Iter: Iterator,
Iter::Item: core::fmt::Debug,
{
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("PutBackPeekMore")
.field("iter", &"...")
.field("peek", &self.peek)
.field("fizz", &self.fizz)
.finish()
}
}
impl<Iter, const PEEK: usize> Iterator for PutBackPeekMore<Iter, PEEK>
where
Iter: Iterator,
{
type Item = Iter::Item;
fn next(&mut self) -> Option<Self::Item> {
self.demand(1);
let out = self.peek[self.fizz].take();
self.fizz += 1;
out
}
}
#[cfg(test)]
mod tests {
extern crate std;
use crate::PutBackPeekMore;
#[test]
fn test_peek_value() {
let mut iter: PutBackPeekMore<core::ops::Range<i32>, 3> = PutBackPeekMore::new(0..10);
assert_eq!(iter.peek_value(3), &[Some(0), Some(1), Some(2)]);
}
#[test]
fn test_peek() {
let mut iter: PutBackPeekMore<core::ops::Range<i32>, 3> = PutBackPeekMore::new(0..10);
assert_eq!(iter.peek(), &Some(0));
}
#[test]
fn test_next() {
let mut iter: PutBackPeekMore<core::ops::Range<i32>, 3> = PutBackPeekMore::new(0..10);
assert_eq!(iter.next(), Some(0));
}
#[test]
fn test_peek_multiple_calls() {
let mut iter: PutBackPeekMore<core::ops::Range<i32>, 3> = PutBackPeekMore::new(0..10);
std::println!("{:#?}", iter);
assert_eq!(iter.peek(), &Some(0));
iter.next();
assert_eq!(iter.peek(), &Some(1));
}
#[test]
fn test_put_back() {
let mut iter: PutBackPeekMore<core::ops::Range<i32>, 3> = PutBackPeekMore::new(0..10);
iter.next();
iter.put_back(Some(0));
assert_eq!(iter.peek(), &Some(0));
}
#[test]
fn peek_value_small() {
let mut iter: PutBackPeekMore<_, 3> = PutBackPeekMore::new(0..10);
iter.next();
assert_eq!(iter.peek_value(3), &[Some(1), Some(2), Some(3)])
}
}