Struct circle_buffer::CircleBuffer

pub struct CircleBuffer<T> where
    T: Clone,  { /* fields omitted */ }

A circular buffer.

Methods

impl<T> CircleBuffer<T> where     T: Clone,

pub fn with_capacity(capacity: usize) -> CircleBuffer<T>

Creates a new empty CircleBuffer<T> with capacity.

Examples

use circle_buffer::CircleBuffer;

let mut cbuf: CircleBuffer<i32> = CircleBuffer::with_capacity(3);

pub fn capacity(&self) -> usize

Returns the capacity of the buffer.

Examples

use circle_buffer::CircleBuffer;

let mut cbuf: CircleBuffer<i32> = CircleBuffer::with_capacity(3);
assert_eq!(3, cbuf.capacity());

pub fn len(&self) -> usize

Returns the current number of elements in the buffer.

Examples

use circle_buffer::CircleBuffer;

let mut cbuf: CircleBuffer<i32> = CircleBuffer::with_capacity(10);
cbuf.push(1);
cbuf.push(1);
cbuf.push(1);

assert_eq!(cbuf.len(), 3);

pub fn is_empty(&self) -> bool

Returns true if the buffer contains no elements.

Examples

use circle_buffer::CircleBuffer;

let mut cbuf: CircleBuffer<i32> = CircleBuffer::with_capacity(3);
assert!(cbuf.is_empty());

cbuf.push(1);
assert!(!cbuf.is_empty())

pub fn push(&mut self, value: T)

Pushes a new element into the buffer. Once the capacity is reached, pushing new items will overwrite old ones.

Examples

use circle_buffer::CircleBuffer;

let mut cbuf: CircleBuffer<i32> = CircleBuffer::with_capacity(3);
cbuf.push(1);
cbuf.push(2);
cbuf.push(3);
cbuf.push(4);

assert_eq!(cbuf.len(), 3);

assert_eq!(cbuf[0], 2);
assert_eq!(cbuf[1], 3);
assert_eq!(cbuf[2], 4);

let mut sum = 0;
for x in cbuf.as_slice() {
    sum += x;
}
assert_eq!(sum, 9);

pub fn as_slice(&self) -> &[T]

Extracts a slice containing the entire buffer.

pub fn as_mut_slice(&mut self) -> &mut [T]

Extracts a mutable slice of the entire buffer.

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

Returns an iterator over the buffer's contents. The iterator goes from the most recently pushed items to the oldest ones.

Examples

use circle_buffer::CircleBuffer;

let mut buffer = CircleBuffer::with_capacity(3);
buffer.push(1);
buffer.push(2);
buffer.push(3);
let add1: Vec<i32> = buffer.iter().map(|x| x + 1).collect();
assert_eq!(add1, vec![2, 3, 4]);

buffer.push(4);
buffer.push(5);
let add2: Vec<i32> = buffer.iter().map(|x| x + 2).collect();
assert_eq!(add2, vec![5, 6, 7]);

pub fn iter_mut(&mut self) -> IterMut<T>

Returns a mutable iterator over the buffer's contents. The iterator goes from the most recently pushed items to the oldest ones.

Examples

use circle_buffer::CircleBuffer;

let mut buffer = CircleBuffer::with_capacity(3);
buffer.push(1);
buffer.push(2);
buffer.push(3);
for x in buffer.iter_mut() {
    *x += 1;
}
assert_eq!(buffer.as_slice(), &[2, 3, 4]);

buffer.push(4);
buffer.push(5);
for x in buffer.iter_mut() {
    *x += 2;
}
assert_eq!(buffer.as_slice(), &[6, 6, 7]);

impl<T> CircleBuffer<T> where     T: Clone + Zero,

pub fn zero_clear(&mut self)

Fill all elements with zeros.

Examples

use circle_buffer::CircleBuffer;

let mut cbuf: CircleBuffer<i32> = CircleBuffer::with_capacity(3);
cbuf.push(1);
cbuf.zero_clear();
assert!(cbuf.len() == 3);
assert_eq!(cbuf.as_slice(), &[0, 0, 0]);

cbuf.push(2);
assert_eq!(cbuf.as_slice(), &[0, 0, 2]);

Trait Implementations

impl<T> Index<usize> for CircleBuffer<T> where     T: Clone,

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &T

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for CircleBuffer<T> where     T: Clone,

fn index_mut(&mut self, index: usize) -> &mut T

Performs the mutable indexing (container[index]) operation.