pub struct Fifo<T: ?Sized, D: DataBuf> { /* private fields */ }
Expand description
A First-In-First-Out queue of DSTs
let mut queue = ::stack_dst::Fifo::<str, ::stack_dst::buffers::Ptr8>::new();
queue.push_back_str("Hello");
queue.push_back_str("World");
assert_eq!(queue.pop_front().as_ref().map(|v| &v[..]), Some("Hello"));
Implementations§
source§impl<T: ?Sized, D: DataBuf> Fifo<T, D>
impl<T: ?Sized, D: DataBuf> Fifo<T, D>
sourcepub fn with_buffer(data: D) -> Self
pub fn with_buffer(data: D) -> Self
Construct a new (empty) list using the provided buffer
sourcepub fn push_back<U: Unsize<T>>(&mut self, v: U) -> Result<(), U>where
(U, D::Inner): AlignmentValid,
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
sourcepub fn push_back_stable<U, F: FnOnce(&U) -> &T>(
&mut self,
v: U,
f: F
) -> Result<(), U>where
(U, D::Inner): AlignmentValid,
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
)
sourcepub fn pop_front(&mut self) -> Option<PopHandle<'_, T, D>>
pub fn pop_front(&mut self) -> Option<PopHandle<'_, T, D>>
Remove an item from the front of the list
sourcepub fn iter(&self) -> Iter<'_, T, D> ⓘ
pub fn iter(&self) -> Iter<'_, T, D> ⓘ
Obtain an immutable iterator (yields references to items, in insertion order)
let mut list = ::stack_dst::Fifo::<str, ::stack_dst::buffers::Ptr8>::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);
sourcepub fn iter_mut(&mut self) -> IterMut<'_, T, D> ⓘ
pub fn iter_mut(&mut self) -> IterMut<'_, T, D> ⓘ
Obtain a mutable iterator
let mut list = ::stack_dst::Fifo::<[u8], ::stack_dst::buffers::Ptr8>::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);
sourcepub fn retain<Cb>(&mut self, cb: Cb)where
Cb: FnMut(&mut T) -> bool,
pub fn retain<Cb>(&mut self, cb: Cb)where Cb: FnMut(&mut T) -> bool,
Remove any items that don’t meet a predicate
use stack_dst::Fifo;
use core::any::Any;
use core::fmt::Debug;
trait DebugAny: 'static + Any + Debug { fn as_any(&self) -> &dyn Any; }
impl<T: Debug + Any + 'static> DebugAny for T { fn as_any(&self) -> &dyn Any { self } }
let mut list = {
let mut list: Fifo<dyn DebugAny, ::stack_dst::buffers::Ptr8> = Fifo::new();
list.push_back_stable(1234, |v| v);
list.push_back_stable(234.5f32, |v| v);
list.push_back_stable(5678, |v| v);
list.push_back_stable(0.5f32, |v| v);
list
};
list.retain(|v| (*v).as_any().downcast_ref::<f32>().is_some());
let mut it = list.iter().map(|v| format!("{:?}", v));
assert_eq!(it.next(), Some("234.5".to_owned()));
assert_eq!(it.next(), Some("0.5".to_owned()));
assert_eq!(it.next(), None);
source§impl<D: DataBuf, T: Clone> Fifo<[T], D>where
(T, D::Inner): AlignmentValid,
impl<D: DataBuf, T: Clone> Fifo<[T], D>where (T, D::Inner): AlignmentValid,
source§impl<D: DataBuf, T> Fifo<[T], D>where
(T, D::Inner): AlignmentValid,
impl<D: DataBuf, T> Fifo<[T], D>where (T, D::Inner): AlignmentValid,
sourcepub fn push_from_iter(
&mut self,
iter: impl ExactSizeIterator<Item = T>
) -> Result<(), ()>
pub fn push_from_iter( &mut self, iter: impl ExactSizeIterator<Item = T> ) -> Result<(), ()>
Push an item, populated from an exact-sized iterator
let mut stack = Fifo::<[u8], ::stack_dst::buffers::Ptr8>::new();
stack.push_from_iter(0..10);
assert_eq!(stack.front().unwrap(), &[0,1,2,3,4,5,6,7,8,9]);
Trait Implementations§
Auto Trait Implementations§
impl<T: ?Sized, D> RefUnwindSafe for Fifo<T, D>where D: RefUnwindSafe, T: RefUnwindSafe,
impl<T, D> !Send for Fifo<T, D>
impl<T, D> !Sync for Fifo<T, D>
impl<T: ?Sized, D> Unpin for Fifo<T, D>where D: Unpin,
impl<T: ?Sized, D> UnwindSafe for Fifo<T, D>where D: UnwindSafe, T: RefUnwindSafe,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more