Struct market::UnlimitedQueue

pub struct UnlimitedQueue<G> { /* fields omitted */ }

Defines a queue with unlimited size that implements Consumer and Producer.

An UnlimitedQueue can be closed, which prevents the Producer from producing new goods while allowing the Consumer to consume only the remaining goods on the queue.

Implementations

impl<G> UnlimitedQueue<G>

#[must_use]pub fn new() -> Self

Creates a new empty UnlimitedQueue.

pub fn close(&self)

Closes self.

Trait Implementations

impl<G> Consumer for UnlimitedQueue<G> where
    G: Debug, 

type Good = G

The item being consumed.

type Fault = ClosedMarketFault

The fault that could be thrown during consumption.

fn consume(&self) -> Result<Self::Good, ConsumeFailure<Self::Fault>>

Retrieves the next good from the market without blocking.

fn consume_all(&self) -> Result<Vec<Self::Good>, Self::Fault>

Retrieves all goods held in the market without blocking.

fn demand(&self) -> Result<Self::Good, Self::Fault>

Retrieves the next good from the market, blocking until one is available.

impl<G: Debug> Debug for UnlimitedQueue<G>

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

Formats the value using the given formatter.

impl<G> Default for UnlimitedQueue<G>

fn default() -> Self

Returns the "default value" for a type.

impl<G> Producer for UnlimitedQueue<G> where
    G: Debug, 

type Good = G

The item being produced.

type Fault = ClosedMarketFault

The fault that could be thrown during production.

fn produce(&self, good: Self::Good) -> Result<(), ProduceFailure<Self::Fault>>

Stores good in the market without blocking.

fn produce_or_recall(
    &self,
    good: Self::Good
) -> Result<(), Recall<Self::Good, Self::Fault>> where
    Self::Good: Clone + Debug, 

Stores good in the market without blocking, returning good on failure.

fn produce_all(
    &self,
    goods: Vec<Self::Good>
) -> Result<(), ProduceFailure<Self::Fault>>

Stores each good in goods in the market without blocking.

fn force(&self, good: Self::Good) -> Result<(), Self::Fault> where
    Self::Good: Clone + Debug,
    Self::Fault: 'static, 

Stores good in the market, blocking until space is available.

fn force_all(&self, goods: Vec<Self::Good>) -> Result<(), Self::Fault> where
    Self::Good: Clone + Debug,
    Self::Fault: 'static, 

Stores every good in goods, blocking until space is available.