Struct command_executor::blocking_queue::BlockingQueue

pub struct BlockingQueue<E>where
    E: Send + Sync,{ /* private fields */ }

Blocking bounded queue

E: Send + Sync - the element type This is a multiple producers / multiple consumers blocking bounded queue. Reference: Producer-Consumer

Implementations

impl<E> BlockingQueue<E>where E: Send + Sync,

pub fn new(capacity: usize) -> BlockingQueue<E>

Create a new queue with size capacity

use command_executor::blocking_queue::BlockingQueue;
let q: BlockingQueue<i32> = BlockingQueue::new(4);

pub fn len(&self) -> usize

The current length of the queue

use command_executor::blocking_queue::BlockingQueue;
let q: BlockingQueue<i32> = BlockingQueue::new(4);
q.enqueue(11);
assert_eq!(q.len(), 1);

pub fn capacity(&self) -> usize

The declared capacity of the queue. May be smaller than the actual capacity of the actual storage

pub fn is_empty(&self) -> bool

Indication if the queue is empty in this point of time.

pub fn is_full(&self) -> bool

Indication if the queue is full in this point of time.

pub fn wait_empty(&self, timeout: Duration) -> bool

Wait until the queue is empty.

Note that the empty state is temporary. This method is mostly useful when we know that no elements are to be enqueued and we want an indication of completion.

pub fn enqueue(&self, element: E)

Enqueue an element. When the queue is full will block until space available.

pub fn try_enqueue(&self, element: E, timeout: Duration) -> Option<E>

Enqueue an element with timeout. When timeout is exceeded return the element to caller.

pub fn dequeue(&self) -> Option<E>

Dequeue an element from the queue. When the queue is empty will block until an element is available

pub fn try_dequeue(&self, timeout: Duration) -> Option<E>

Dequeue and element from the queue with timeout.