Struct fixed_vec_deque::FixedVecDeque
source · pub struct FixedVecDeque<T>where
T: Array,{ /* private fields */ }
Expand description
A double-ended queue implemented with a fixed buffer.
Implementations
sourceimpl<T> FixedVecDeque<T>where
T: Array,
impl<T> FixedVecDeque<T>where
T: Array,
sourcepub fn is_empty(&self) -> bool
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());
sourcepub fn is_full(&self) -> bool
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());
sourcepub fn len(&self) -> usize
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);
sourcepub fn front(&self) -> Option<&T::Item>
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));
sourcepub fn front_mut(&mut self) -> Option<&mut T::Item>
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));
sourcepub fn back(&self) -> Option<&T::Item>
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));
sourcepub fn back_mut(&mut self) -> Option<&mut T::Item>
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));
sourcepub fn push_front(&mut self) -> &mut T::Item
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));
sourcepub fn pop_front(&mut self) -> Option<&T::Item>
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);
sourcepub fn push_back(&mut self) -> &mut T::Item
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);
sourcepub fn pop_back(&mut self) -> Option<&T::Item>
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));
sourcepub fn iter<'a>(&'a self) -> Iter<'a, T> ⓘ
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);
sourcepub fn clear(&mut self)
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());
sourcepub fn as_mut_slices(&mut self) -> (&mut [T::Item], &mut [T::Item])
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][..]));
sourcepub fn as_slices(&self) -> (&[T::Item], &[T::Item])
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][..]));