Remove Segments From an Iterator

sanitizer.rs

struct Sanitizer<I: Iterator> {
    iter: PeekMoreIterator<I>,
    needle: Vec<I::Item>,
}

impl<I: Iterator> Sanitizer<I>
where
    I::Item: PartialEq,
{
    fn new(haystack: I, needle: Vec<I::Item>) -> Self {
        Sanitizer {
            iter: haystack.peekmore(),
            needle,
        }
    }

    fn advance(&mut self) {
        for i in 0..self.needle.len() {
            let next = match self.iter.peek() {
                Some(n) => n,
                None => {
                    self.iter.reset_cursor();
                    return;
                }
            };

            if next != &self.needle[i] {
                self.iter.reset_cursor();
                return;
            }

            self.iter.advance_cursor();
        }

        // we found the needle, so drop it on the floor
        self.iter.truncate_iterator_to_cursor();
    }
}

impl<I: Iterator> Iterator for Sanitizer<I>
where
    I::Item: PartialEq,
{
    type Item = I::Item;

    fn next(&mut self) -> Option<Self::Item> {
        self.advance();
        self.iter.next()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn sanitize_middle() {
        let sanitizer = Sanitizer::new("here are some bytes".bytes(), "some ".bytes().collect());
        let result: String = String::from_utf8(sanitizer.collect()).unwrap();
        assert_eq!(result, "here are bytes");
    }

    #[test]
    fn sanitize_front() {
        let sanitizer = Sanitizer::new("here are some bytes".bytes(), "here ".bytes().collect());
        let result: String = String::from_utf8(sanitizer.collect()).unwrap();
        assert_eq!(result, "are some bytes");
    }

    #[test]
    fn sanitize_end() {
        let sanitizer = Sanitizer::new("here are some bytes".bytes(), " bytes".bytes().collect());
        let result: String = String::from_utf8(sanitizer.collect()).unwrap();
        assert_eq!(result, "here are some");
    }
}