Struct hoop::Hoop

pub struct Hoop<T: Clone> { /* fields omitted */ }

Yet another ring buffer implmentation. This one has ability to iterate both ways without mutation buffer.

Usage

use hoop::Hoop;

let mut buffer = Hoop::with_capacity(4);
buffer.write('1');
buffer.write('2');
buffer.write('3');
buffer.write('4');
let mut iter = buffer.iter();
assert_eq!(Some(&'1'), iter.next());
assert_eq!(Some(&'4'), iter.next_back());
assert_eq!(Some(&'2'), iter.next());
assert_eq!(Some(&'3'), iter.next_back());
assert_eq!(None, iter.next());
assert_eq!(None, iter.next_back());

Methods

impl<T: Clone> Hoop<T>

fn with_capacity(capacity: usize) -> Hoop<T>

Create new ring buffer with desired capacity.

fn capacity(&self) -> usize

Capacity of inner Vec.

fn pop(&mut self) -> Option<T>

Pop oldest item from a buffer.

fn write(&mut self, item: T) -> WriteResult

Try writting to a buffer.

fn overwrite(&mut self, item: T)

Write even if at a capacity. This ither is a normal write or overwrite + move read position forward.

fn clear(&mut self)

Clear buffer. This is O(n) operation.

fn iter(&self) -> Iter<T>

Create non-consuming iterator.