Struct dvcompute::simulation::queue::Queue

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

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

Implementations

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

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

Create a new bounded queue by the specified strategies and capacity.

pub fn max_count(&self) -> isize

Return the queue capacity, i.e. its maximum size.

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

Test whether the queue is empty.

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

Test whether the queue is full.

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

Return the current queue size.

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

Return the load factor: the queue size divided by its capacity, i.e. maximum 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 Process<Item = ()>

Enqueue the item by suspending the process if the queue is full.

pub fn enqueue_with_input_priority(
    queue: Rc<Self>,
    pi: SI::Priority,
    item: T
) -> impl Process<Item = ()> where
    SI::Priority: Clone, 

Enqueue the item with input priority by suspending the process if the queue is full.

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

Enqueue the item with storing priority by suspending the process if the queue is full.

pub fn enqueue_with_input_and_storing_priorities(
    queue: Rc<Self>,
    pi: SI::Priority,
    pm: SM::Priority,
    item: T
) -> impl Process<Item = ()> where
    SI::Priority: Clone,
    SM::Priority: Clone, 

Enqueue the item with input and storing priorities by suspending the process if the queue is full.

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

Try to enqueue the item. Return false within Event computation if the queue is full.

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

Try to enqueue the item with storing priority. Return false within Event computation if the queue is full.