Struct Queue

pub struct Queue<T> { /* private fields */ }

Implementations

impl<T> Queue<T>

pub fn iter(&self) -> impl Iterator<Item = &ItemInfo<T>>

impl<T: Clone> Queue<T>

pub const fn new(tick_id: TickId) -> Self

pub fn clear(&mut self, initial_tick_id: TickId)

Clears the queue and resets the expected read and write tick IDs.

pub fn push(&mut self, tick_id: TickId, item: T) -> Result<(), QueueError>

Pushes an item into the queue at the specified TickId.

This method ensures that the item is added at the correct position in the tick sequence. The tick_id must match the expected TickId for the queue to maintain an unbroken sequence.

Parameters

• tick_id: The TickId where the item should be inserted. It must match the queue’s expected next TickId.
• item: The item to be inserted into the queue.

Returns

• Ok(()) if the item is successfully added to the queue.
• Err(QueueError) if the provided tick_id does not match the expected TickId.

Errors

• Returns a QueueError::WrongTickId if the tick_id provided does not match the expected TickId, which maintains the sequential order of the queue.

pub fn debug_get(&self, index: usize) -> Option<&ItemInfo<T>>

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

pub fn discard_up_to(&mut self, tick_id: TickId)

pub fn discard_count(&mut self, count: usize)

pub fn take(&mut self, count: usize) -> Option<(TickId, Vec<T>)>

Pops up to a certain amount of items from the front of the queue and returns the first TickId and a vector of T. Returns None if the queue is empty.

Parameters

• count: The number of items to pop (or fewer if not enough items are available).

Returns

• Some((TickId, Vec<T>)) if there are items available.
• None if the queue is empty.

Example

use tick_id::TickId;
use tick_queue::Queue;
let mut items = Queue::new(TickId::new(0));
items.push(TickId::new(0), "Step 1").unwrap();
items.push(TickId::new(1), "Step 2").unwrap();

let result = items.take(5);  // Will return up to 5 items (in this case 2)
if let Some((tick_id, popped_items)) = result {
    assert_eq!(tick_id, TickId::new(0));
    assert_eq!(popped_items, vec!["Step 1", "Step 2"]);
}

pub fn front_tick_id(&self) -> Option<TickId>

pub const fn expected_write_tick_id(&self) -> TickId

pub fn back_tick_id(&self) -> Option<TickId>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn to_vec(&self) -> Vec<T>

pub const fn iter_index(&self, start_index: usize) -> FromIndexIterator<'_, T>

Trait Implementations

impl<T: Debug> Debug for Queue<T>

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

Formats the value using the given formatter.

impl<T> Default for Queue<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> IntoIterator for Queue<T>

fn into_iter(self) -> Self::IntoIter

Consumes the Queue collection and returns an iterator over the items.

This allows the use of the for loop and other iterator methods without manually calling iter().

type Item = ItemInfo<T>

The type of the elements being iterated over.

type IntoIter = IntoIter<ItemInfo<T>>

Which kind of iterator are we turning this into?