Struct dvcompute::simulation::queue::stats::Queue

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

Represents a 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_empty_changed(
    queue: Rc<Self>
) -> impl Observable<Message = bool> + Clone

Notifies when the is_empty property changes.

pub fn is_empty_changed_(&self) -> impl Observable<Message = ()> + Clone

Notifies when the is_empty property changes.

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

Test whether the queue is full.

pub fn is_full_changed(
    queue: Rc<Self>
) -> impl Observable<Message = bool> + Clone

Notifies when the is_full property changes.

pub fn is_full_changed_(&self) -> impl Observable<Message = ()> + Clone

Notifies when the is_full property changes.

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

Return the current queue size.

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

Return the statistics for the queue size.

pub fn count_changed(
    queue: Rc<Self>
) -> impl Observable<Message = isize> + Clone

Notifies when the count property changes.

pub fn count_changed_(&self) -> impl Observable<Message = ()> + Clone

Notifies when the count property changes.

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

Return the total number of enqueue operations, including those ones that have failed due to full capacity.

pub fn enqueue_count_changed(
    queue: Rc<Self>
) -> impl Observable<Message = isize> + Clone

Notifies when the enqueue_count property changes.

pub fn enqueue_count_changed_(&self) -> impl Observable<Message = ()> + Clone

Notifies when the enqueue_count property changes.

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

Return the total number of items that could not be enqueued due to full capacity.

pub fn enqueue_lost_count_changed(
    queue: Rc<Self>
) -> impl Observable<Message = isize> + Clone

Notifies when the enqueue_lost_count property changes.

pub fn enqueue_lost_count_changed_(
    &self
) -> impl Observable<Message = ()> + Clone

Notifies when the enqueue_lost_count property changes.

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

Return the total number of input items that were stored.

pub fn enqueue_store_count_changed(
    queue: Rc<Self>
) -> impl Observable<Message = isize> + Clone

Notifies when the enqueue_store_count property changes.

pub fn enqueue_store_count_changed_(
    &self
) -> impl Observable<Message = ()> + Clone

Notifies when the enqueue_store_count property changes.

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

Return the total number of requests to dequeue the items.

pub fn dequeue_count_changed(
    queue: Rc<Self>
) -> impl Observable<Message = isize> + Clone

Notifies when the dequeue_count property changes.

pub fn dequeue_count_changed_(&self) -> impl Observable<Message = ()> + Clone

Notifies when the dequeue_count property changes.

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

Return the total number of items that were extracted from the queue with help of dequeue operations.

pub fn dequeue_extract_count_changed(
    queue: Rc<Self>
) -> impl Observable<Message = isize> + Clone

Notifies when the dequeue_extract_count property changes.

pub fn dequeue_extract_count_changed_(
    &self
) -> impl Observable<Message = ()> + Clone

Notifies when the dequeue_extract_count property changes.

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 load_factor_changed(
    queue: Rc<Self>
) -> impl Observable<Message = f64> + Clone

Notifies when the load_factor property changes.

pub fn load_factor_changed_(&self) -> impl Observable<Message = ()> + Clone

Notifies when the load_factor property changes.

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

Return the rate of input items that were enqueued: how many items per time.

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

Return the rate of input items that were stored: how many items per time.

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

Return the rate of requests for dequeueing the items: how many items per time. It does not include the failed attempts to dequeue immediately without suspension.

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

Return the rate of output items that were actually extracted from the queue: how many items per time.

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

Return the wait time from the time at which the item was stored in the queue to the time at which it was dequeued.

pub fn wait_time_changed(
    queue: Rc<Self>
) -> impl Observable<Message = SamplingStats<f64>> + Clone

Notifies when the wait_time property changes.

pub fn wait_time_changed_(&self) -> impl Observable<Message = ()> + Clone

Notifies when the wait_time property changes.

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

Return the total wait time from the time at which the enqueue operation was initiated to the time at which the item was dequeued.

In some sense, total_wait_time == enqueue_wait_time + wait_time.

pub fn total_wait_time_changed(
    queue: Rc<Self>
) -> impl Observable<Message = SamplingStats<f64>> + Clone

Notifies when the total_wait_time property changes.

pub fn total_wait_time_changed_(&self) -> impl Observable<Message = ()> + Clone

Notifies when the total_wait_time property changes.

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

Return the enqueue wait time from the time at which the enqueue operation was initiated to the time at which the item was stored in the queue.

pub fn enqueue_wait_time_changed(
    queue: Rc<Self>
) -> impl Observable<Message = SamplingStats<f64>> + Clone

Notifies when the enqueue_wait_time property changes.

pub fn enqueue_wait_time_changed_(
    &self
) -> impl Observable<Message = ()> + Clone

Notifies when the enqueue_wait_time property changes.

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

Return the dequeue wait time from the time at which the dequeue request was made to the time at which the corresponding item was actually dequeued.

pub fn dequeue_wait_time_changed(
    queue: Rc<Self>
) -> impl Observable<Message = SamplingStats<f64>> + Clone

Notifies when the dequeue_wait_time property changes.

pub fn dequeue_wait_time_changed_(
    &self
) -> impl Observable<Message = ()> + Clone

Notifies when the dequeue_wait_time property changes.

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

Return a long-term average queue rate calculated as the average queue size divided by the average wait time.

This value may be less than the actual arrival rate as the queue is bounded and new arrivals may be blocked while the queue remains full.

pub fn rate_changed(queue: Rc<Self>) -> impl Observable<Message = f64> + Clone

Notifies when the rate property changes.

pub fn rate_changed_(&self) -> impl Observable<Message = ()> + Clone

Notifies when the rate property changes.

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.

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

Try to enqueue the item. If the queue is full then the item will be counted as lost and false will be returned.

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

Try to enqueue the item with storing piority. If the queue is full then the item will be counted as lost and false will be returned.

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

Try to enqueue the item. If the queue is full then the item will be counted as lost.

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

Try to enqueue the item with storing priority. If the queue is full then the item will be counted as lost.

pub fn enqueue_initiated(&self) -> impl Observable<Message = T> + Clone

Notifies when the enqueue operation is initiated.

pub fn enqueue_stored(&self) -> impl Observable<Message = T> + Clone

Notifies when the item to be enqueued is stored.

pub fn enqueue_lost(&self) -> impl Observable<Message = T> + Clone

Notifies when the item that would have to be enqueued is lost.

pub fn dequeue_requested(&self) -> impl Observable<Message = ()> + Clone

Notifies when the dequeue operation is requested for.

pub fn dequeue_extracted(&self) -> impl Observable<Message = T> + Clone

Notifies when the item is dequeued.

pub fn changed_(&self) -> impl Observable<Message = ()> + Clone

Notifies whenever any property changes.

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

Reset the statistics.

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

Wait while the queue is full.