Struct stack_dst::list::FifoA

pub struct FifoA<T: ?Sized, D: DataBuf> { /* private fields */ }

A First-In-First-Out queue of DSTs

let mut queue = ::stack_dst::FifoA::<str, [usize; 8]>::new();
queue.push_back_str("Hello");
queue.push_back_str("World");
assert_eq!(queue.pop_front().as_deref(), Some("Hello"));

Implementations

impl<T: ?Sized, D: DataBuf> FifoA<T, D>

pub fn new() -> Self where
    D: Default, 

Construct a new (empty) list

pub fn with_buffer(data: D) -> Self

Construct a new (empty) list using the provided buffer

pub fn push_back<U: Unsize<T>>(&mut self, v: U) -> Result<(), U> where
    (U, D::Inner): AlignmentValid, 

Push a value at the top of the stack

pub fn push_back_stable<U, F: FnOnce(&U) -> &T>(
    &mut self,
    v: U,
    f: F
) -> Result<(), U> where
    (U, D::Inner): AlignmentValid, 

Push a value to the end of the list (without using Unsize)

pub fn compact(&mut self)

Compact the list (moving the read position to zero)

pub fn empty(&self) -> bool

Checks if the queue is currently empty

pub fn pop_front(&mut self) -> Option<PopHandle<'_, T, D>>

Remove an item from the front of the list

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

Peek the front of the queue

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

Peek the front of the queue

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

Obtain an immutable iterator (yields references to items, in insertion order)

let mut list = ::stack_dst::FifoA::<str, [usize; 8]>::new();
list.push_back_str("Hello");
list.push_back_str("world");
let mut it = list.iter();
assert_eq!(it.next(), Some("Hello"));
assert_eq!(it.next(), Some("world"));
assert_eq!(it.next(), None);

pub fn iter_mut(&mut self) -> IterMut<'_, T, D>

Obtain a mutable iterator

let mut list = ::stack_dst::FifoA::<[u8], [usize; 8]>::new();
list.push_copied(&[1,2,3]);
list.push_copied(&[9]);
for v in list.iter_mut() {
    v[0] -= 1;
}
let mut it = list.iter();
assert_eq!(it.next(), Some(&[0,2,3][..]));
assert_eq!(it.next(), Some(&[8][..]));
assert_eq!(it.next(), None);

impl<D: DataBuf> FifoA<str, D>

pub fn push_back_str(&mut self, v: &str) -> Result<(), ()>

Push the contents of a string slice as an item onto the stack

impl<D: DataBuf, T: Clone> FifoA<[T], D>

pub fn push_cloned(&mut self, v: &[T]) -> Result<(), ()>

Pushes a set of items (cloning out of the input slice)

let mut queue = FifoA::<[String],[usize; 16]>::new();
queue.push_cloned(&["1".to_owned()]);

pub fn push_copied(&mut self, v: &[T]) -> Result<(), ()> where
    T: Copy, 

Pushes a set of items (copying out of the input slice)

let mut queue = FifoA::<[usize],[usize; 4]>::new();
queue.push_copied(&[1]);

Trait Implementations

impl<D: DataBuf, T: ?Sized> Debug for FifoA<T, D> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: ?Sized, D: DataBuf + Default> Default for FifoA<T, D>

fn default() -> Self

Returns the “default value” for a type.

impl<T: ?Sized, D: DataBuf> Drop for FifoA<T, D>

fn drop(&mut self)

Executes the destructor for this type.