Struct backtracking_iterator::BacktrackingRecorder

pub struct BacktrackingRecorder<Iter>where
    Iter: Iterator,{ /* private fields */ }

A wrapper around an existing iterator to give it a historical representation with the ability to then produce copying and referencing backtracking iterators on the history

Implementations

impl<Iter> BacktrackingRecorder<Iter>where
    Iter: Iterator,

pub fn new(iterator: Iter) -> Self

Create a BacktrackingRecorder from an existing iterator.

pub fn referencing<'record>(
    &'record mut self
) -> ReferencingBacktrackingIterator<'record, Iter>

pub fn copying<'record>(
    &'record mut self
) -> CopyingBacktrackingIterator<'record, Iter> where
    Iter::Item: Clone,

pub fn drain_history(&mut self) -> Vec<Iter::Item>

Take all items out of the history.

extern crate backtracking_iterator;
use backtracking_iterator::{BacktrackingIterator, BacktrackingRecorder};

let vec_iter = vec![1_u8, 2, 3].into_iter();
let mut rec = BacktrackingRecorder::new(vec_iter);

{
  let mut bt_ref = rec.referencing();
  bt_ref.next(); // 1_u8
}

let mut history = rec.drain_history().into_iter();
// Repeats only what was in the history
assert!(history.next().unwrap() == 1_u8);
assert!(history.next().is_none());

Trait Implementations

impl<Iter, Item> IntoIterator for BacktrackingRecorder<Iter>where
    Iter: Iterator<Item = Item> + IntoIterator<Item = Item>,

fn into_iter(self) -> Self::IntoIter

Destroy the record and return an iterator which starts from the beginning of the history and chains into the originally-given iterator

extern crate backtracking_iterator;
use backtracking_iterator::{BacktrackingIterator, BacktrackingRecorder};

let vec_iter = vec![1_u8, 2, 3].into_iter();
let mut rec = BacktrackingRecorder::new(vec_iter);

{
  let mut bt_ref = rec.referencing();
  bt_ref.next(); // 1_u8
}

let mut rec_iter = rec.into_iter();
// Repeats the value in the history
assert!(rec_iter.next().unwrap() == 1_u8);
// And follows up with the ones not yet recorded
assert!(rec_iter.next().unwrap() == 2_u8);
assert!(rec_iter.next().unwrap() == 3_u8);
assert!(rec_iter.next().is_none());

type Item = Item

The type of the elements being iterated over.

type IntoIter = Chain<IntoIter<Item, Global>, <Iter as IntoIterator>::IntoIter>

Which kind of iterator are we turning this into?

impl<Iter> Record for BacktrackingRecorder<Iter>where
    Iter: Iterator,

type RefPoint = usize

The type used to refer to positions in the history

fn get_ref_point(&self) -> usize

Yield a reference to the current point in the history This reference must be valid for as long as the current point remains in the history

fn forget_before(&mut self, position: usize)

Eliminate all the values before the given reference point from the history

fn forget(&mut self)

Forget all the values before the current position in the iterator