Struct dvcompute::simulation::queue::unbounded::Queue

pub struct Queue<SM, SO, T> where
    SM: QueueStrategy,
    SO: QueueStrategy,  { /* fields omitted */ }

Represents an optimized unbounded queue by using the specified strategies for internal storing (in memory), SM, and dequeueing (output), SO, where T denotes the type of items stored in the queue.

Implementations

impl<SM, SO, T> Queue<SM, SO, T> where
    SM: QueueStrategy + 'static,
    SO: QueueStrategy + 'static,
    T: Clone + 'static, 

pub fn new(storing_strategy: SM, dequeue_strategy: SO) -> NewQueue<SM, SO, T>

Create a new unbounded queue by the specified strategies.

pub fn is_empty(queue: Rc<Self>) -> impl Event<Item = bool> + Clone

Test whether the queue is empty.

pub fn count(queue: Rc<Self>) -> impl Event<Item = isize> + Clone

Return the current queue size.

pub fn dequeue(queue: Rc<Self>) -> impl Process<Item = T>

Dequeue by suspending the process if the queue is empty.

pub fn dequeue_with_output_priority(
    queue: Rc<Self>,
    po: SO::Priority
) -> impl Process<Item = T> where
    SO::Priority: Clone, 

Dequeue with output prioerity by suspending the process if the queue is empty.

pub fn try_dequeue(queue: Rc<Self>) -> impl Event<Item = Option<T>>

Try to dequeue immediately.

pub fn delete(queue: Rc<Self>, item: T) -> impl Event<Item = bool> where
    T: PartialEq, 

Remove the item from the queue and return a flag indicating whether the item was found and actually removed.

pub fn delete_(queue: Rc<Self>, item: T) -> impl Event<Item = ()> where
    T: PartialEq, 

Remove the specified item from the queue.

pub fn delete_by<F>(queue: Rc<Self>, pred: F) -> impl Event<Item = Option<T>> where
    F: Fn(&T) -> bool + 'static, 

Remove an item satisfying the specified predicate and return the item if found.

pub fn exists<F>(queue: Rc<Self>, pred: F) -> impl Event<Item = bool> where
    F: Fn(&T) -> bool + 'static, 

Test whether there is an item satisfying the specified predicate.

pub fn find<F>(queue: Rc<Self>, pred: F) -> impl Event<Item = Option<T>> where
    F: Fn(&T) -> bool + 'static,
    T: Clone, 

Find an item satisfying the specified predicate.

pub fn clear(queue: Rc<Self>) -> impl Event<Item = ()>

Clear the queue.

pub fn enqueue(queue: Rc<Self>, item: T) -> impl Event<Item = ()>

Enqueue the item.

pub fn enqueue_with_storing_priority(
    queue: Rc<Self>,
    pm: SM::Priority,
    item: T
) -> impl Event<Item = ()> where
    SM::Priority: Clone, 

Enqueue the item with storing priority.