Struct fixed_vec_deque::FixedVecDeque

pub struct FixedVecDeque<T>where
    T: Array,{ /* private fields */ }

A double-ended queue implemented with a fixed buffer.

Implementations

impl<T> FixedVecDeque<T>where
    T: Array,

pub fn new() -> Self

Construct a new fixed ring buffer, pre-allocating all elements.

Examples

pub fn is_empty(&self) -> bool

Returns true if the FixedVecDeque is empty.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut v = FixedVecDeque::<[u32; 1]>::new();
assert!(v.is_empty());
*v.push_front() = 1;
assert!(!v.is_empty());

pub fn is_full(&self) -> bool

Returns true if the FixedVecDeque is full.

Writing to a queue that is full will overwrite existing elements.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut v = FixedVecDeque::<[u32; 1]>::new();
assert!(!v.is_full());
*v.push_front() = 1;
assert!(v.is_full());

pub fn len(&self) -> usize

Returns the number of elements in the FixedVecDeque.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut v = FixedVecDeque::<[u32; 2]>::new();
assert_eq!(v.len(), 0);
*v.push_back() = 1;
assert_eq!(v.len(), 1);
*v.push_back() = 1;
assert_eq!(v.len(), 2);

pub fn front(&self) -> Option<&T::Item>

Provides a reference to the front element, or None if the FixedVecDeque is empty.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut d = FixedVecDeque::<[u32; 2]>::new();
assert_eq!(d.front(), None);

*d.push_back() = 1;
*d.push_back() = 2;
assert_eq!(d.front(), Some(&1));

pub fn front_mut(&mut self) -> Option<&mut T::Item>

Provides a mutable reference to the front element, or None if the FixedVecDeque is empty.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut d = FixedVecDeque::<[u32; 2]>::new();

assert_eq!(d.front_mut(), None);

*d.push_back() = 1;
*d.push_back() = 2;

match d.front_mut() {
    Some(x) => *x = 9,
    None => (),
}

assert_eq!(d.front(), Some(&9));
assert_eq!(d.back(), Some(&2));

pub fn back(&self) -> Option<&T::Item>

Provides a reference to the back element, or None if the FixedVecDeque is empty.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut d = FixedVecDeque::<[u32; 2]>::new();

assert_eq!(d.back(), None);

*d.push_back() = 1;
*d.push_back() = 2;
assert_eq!(d.back(), Some(&2));

pub fn back_mut(&mut self) -> Option<&mut T::Item>

Provides a mutable reference to the back element, or None if the FixedVecDeque is empty.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut d = FixedVecDeque::<[u32; 2]>::new();

assert_eq!(d.back(), None);

*d.push_back() = 1;
*d.push_back() = 2;

match d.back_mut() {
    Some(x) => *x = 9,
    None => (),
}
assert_eq!(d.back(), Some(&9));

pub fn push_front(&mut self) -> &mut T::Item

Prepends an element to the FixedVecDeque.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut d = FixedVecDeque::<[u32; 3]>::new();

assert_eq!(d.front(), None);
assert_eq!(d.back(), None);

*d.push_front() = 1;
assert_eq!(d.front(), Some(&1));
assert_eq!(d.back(), Some(&1));

*d.push_front() = 2;
assert_eq!(d.front(), Some(&2));
assert_eq!(d.back(), Some(&1));

*d.push_front() = 3;
assert_eq!(d.front(), Some(&3));
assert_eq!(d.back(), Some(&1));

*d.push_front() = 4;
assert_eq!(d.front(), Some(&4));
assert_eq!(d.back(), Some(&2));

pub fn pop_front(&mut self) -> Option<&T::Item>

Removes the first element and returns it, or None if the FixedVecDeque is empty.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut d = FixedVecDeque::<[u32; 2]>::new();
*d.push_back() = 1;
*d.push_back() = 2;

assert_eq!(d.pop_front(), Some(&1));
assert_eq!(d.pop_front(), Some(&2));
assert_eq!(d.pop_front(), None);

pub fn push_back(&mut self) -> &mut T::Item

Appends an element to the back of the FixedVecDeque by returning a mutable reference that can be modified to it.

Note: this might potentially remove elements from the head, unless they have been read.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut buf = FixedVecDeque::<[u32; 2]>::new();
assert_eq!(buf.back(), None);
assert_eq!(buf.front(), None);

*buf.push_back() = 1;

assert_eq!(buf.front(), Some(&1));
assert_eq!(buf.back(), Some(&1));

*buf.push_back() = 2;

assert_eq!(buf.front(), Some(&1));
assert_eq!(buf.back(), Some(&2));

*buf.push_back() = 3;

assert_eq!(buf.front(), Some(&2));
assert_eq!(buf.back(), Some(&3));

use fixed_vec_deque::FixedVecDeque;

let mut buf = FixedVecDeque::<[u32; 1]>::new();
assert_eq!(buf.back(), None);
assert_eq!(buf.front(), None);

*buf.push_back() = 1;

assert_eq!(buf.front(), Some(&1));
assert_eq!(buf.back(), Some(&1));

*buf.push_back() = 2;

assert_eq!(buf.front(), Some(&2));
assert_eq!(buf.back(), Some(&2));

buf.pop_back();

assert!(buf.is_empty());
assert_eq!(buf.back(), None);
assert_eq!(buf.front(), None);

pub fn pop_back(&mut self) -> Option<&T::Item>

Removes the last element from the FixedVecDeque and returns a reference to it, or None if it is empty.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut buf = FixedVecDeque::<[u32; 2]>::new();
assert_eq!(buf.pop_back(), None);
*buf.push_back() = 1;
*buf.push_back() = 3;
assert_eq!(buf.pop_back(), Some(&3));

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

Returns a front-to-back iterator.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut buf = FixedVecDeque::<[u32; 4]>::new();
*buf.push_back() = 5;
*buf.push_back() = 3;
*buf.push_back() = 4;

let b: &[_] = &[&5, &3, &4];
let c: Vec<&u32> = buf.iter().collect();
assert_eq!(&c[..], b);

pub fn clear(&mut self)

Clears the FixedVecDeque.

The stored values will not be deleted.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut v = FixedVecDeque::<[u32; 1]>::new();
*v.push_back() = 1;
v.clear();
assert!(v.is_empty());

pub fn as_mut_slices(&mut self) -> (&mut [T::Item], &mut [T::Item])

Returns a pair of slices which contain, in order, the contents of the FixedVecDeque.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut vector = FixedVecDeque::<[u32; 6]>::new();

*vector.push_back() = 0;
*vector.push_back() = 1;

*vector.push_front() = 10;
*vector.push_front() = 9;

vector.as_mut_slices().0[0] = 42;
vector.as_mut_slices().1[0] = 24;

assert_eq!(vector.as_slices(), (&[42, 10][..], &[24, 1][..]));

pub fn as_slices(&self) -> (&[T::Item], &[T::Item])

Returns a pair of slices which contain, in order, the contents of the FixedVecDeque.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut vector = FixedVecDeque::<[u32; 5]>::new();

*vector.push_back() = 1;
*vector.push_back() = 2;
*vector.push_back() = 3;

assert_eq!(vector.as_slices(), (&[1, 2, 3][..], &[][..]));

*vector.push_front() = 4;
*vector.push_front() = 5;

assert_eq!(vector.as_slices(), (&[5, 4][..], &[1, 2, 3][..]));

Trait Implementations

impl<'a, T: 'a> IntoIterator for &'a FixedVecDeque<T>where
    T: Array,

type Item = &'a <T as Array>::Item

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.