Struct concurrency_traits::queue::SemaphoreQueue

pub struct SemaphoreQueue<T, S, CS> { /* fields omitted */ }

A queue based on a semaphore to block on.

Implementations

impl<T, S, CS> SemaphoreQueue<T, S, CS> where
    S: ReadoutSemaphore, 

pub fn len(&self) -> S::Count

Gets the length of the queue.

pub fn is_empty(&self) -> bool where
    S::Count: Zero, 

Tells whether the queue is empty.

Trait Implementations

impl<T, S, CS> AsyncPrependQueue for SemaphoreQueue<T, S, CS> where
    T: Send,
    S: AsyncSemaphore + Send + Sync,
    CS: ThreadFunctions, 

fn push_front_async<'life0, 'async_trait>(
    &'life0 self,
    value: Self::Item
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Adds to the front of the queue asynchronously

impl<T, S, CS> AsyncQueue for SemaphoreQueue<T, S, CS> where
    T: Send,
    S: AsyncSemaphore + Send + Sync,
    CS: ThreadFunctions, 

fn push_async<'life0, 'async_trait>(
    &'life0 self,
    value: Self::Item
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Appends to the queue asynchronously.

fn pop_async<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Self::Item> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Receives from the queue asynchronously.

impl<T, S, CS> AsyncReverseQueue for SemaphoreQueue<T, S, CS> where
    T: Send,
    S: AsyncSemaphore + Send + Sync,
    CS: ThreadFunctions, 

fn pop_back_async<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Self::Item> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Reads the back of the queue

impl<T, S, CS> AsyncTimeoutQueue for SemaphoreQueue<T, S, CS> where
    T: Send,
    S: AsyncTimeoutSemaphore + Send + Sync,
    CS: ThreadFunctions, 

fn push_timeout_async<'life0, 'async_trait>(
    &'life0 self,
    value: Self::Item,
    __arg2: Duration
) -> Pin<Box<dyn Future<Output = Result<(), Self::Item>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Pushes an item to the queue asynchronously with a timeout

fn pop_timeout_async<'life0, 'async_trait>(
    &'life0 self,
    timeout: Duration
) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Pops an item from the queue asynchronously with a timeout

impl<T: Debug, S: Debug, CS: Debug> Debug for SemaphoreQueue<T, S, CS>

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

Formats the value using the given formatter.

impl<T, S, CS> Default for SemaphoreQueue<T, S, CS> where
    S: Default, 

fn default() -> Self

Returns the “default value” for a type.

impl<T, S, CS> PrependQueue for SemaphoreQueue<T, S, CS> where
    S: Semaphore,
    CS: ThreadFunctions, 

fn push_front(&self, value: Self::Item)

Adds an item to the front of the queue blocking until able

impl<T, S, CS> Queue for SemaphoreQueue<T, S, CS> where
    S: Semaphore,
    CS: ThreadFunctions, 

fn push(&self, value: Self::Item)

Appends an item to the end of the queue blocking until appended

fn pop(&self) -> Self::Item

Blocks until an item is received from the queue

impl<T, S, CS> ReverseQueue for SemaphoreQueue<T, S, CS> where
    S: Semaphore,
    CS: ThreadFunctions, 

fn pop_back(&self) -> Self::Item

Reads from the back of the queue

impl<T, S, CS> TimeoutQueue for SemaphoreQueue<T, S, CS> where
    S: TimeoutSemaphore,
    CS: ThreadFunctions, 

fn push_timeout(&self, value: Self::Item, _: Duration) -> Result<(), Self::Item>

Appends an item to the end of the queue blocking until appended or timeout

fn pop_timeout(&self, timeout: Duration) -> Option<Self::Item>

Blocks until an item is received from the queue or timeout

impl<T, S, CS> TryPrependQueue for SemaphoreQueue<T, S, CS> where
    S: TrySemaphore,
    CS: ThreadFunctions, 

fn try_push_front(&self, value: Self::Item) -> Result<(), Self::Item>

Adds an item to the front of the queue without blocking

impl<T, S, CS> TryQueue for SemaphoreQueue<T, S, CS> where
    S: TrySemaphore,
    CS: ThreadFunctions, 

type Item = T

The type the queue holds.

fn try_push(&self, value: Self::Item) -> Result<(), Self::Item>

Tries to append an item to the queue returning None if unsuccessful

fn try_pop(&self) -> Option<Self::Item>

Tries to receive an item from the queue returning None if none available

impl<T, S, CS> TryReverseQueue for SemaphoreQueue<T, S, CS> where
    S: TrySemaphore,
    CS: ThreadFunctions, 

fn try_pop_back(&self) -> Option<Self::Item>

Non blocking version of receive_back

impl<T, S, CS> AsyncDoubleEndedQueue for SemaphoreQueue<T, S, CS> where
    T: Send,
    S: AsyncSemaphore + Send + Sync,
    CS: ThreadFunctions, 

impl<T, S, CS> DoubleEndedQueue for SemaphoreQueue<T, S, CS> where
    S: Semaphore,
    CS: ThreadFunctions, 

impl<T, S, CS> TryDoubleEndedQueue for SemaphoreQueue<T, S, CS> where
    S: TrySemaphore,
    CS: ThreadFunctions,