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 type of the item being consumed.

type Failure = ClosedMarketFailure

The type of the error that could be thrown during consumption.

fn consume(&self) -> Result<Self::Good, ConsumeError<Self::Failure>>

Retrieves the next good from the market without blocking.

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

Retrieves all goods held in the market without blocking.

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

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

fn adapt<G, F>(self) -> Adapter<Self, G, F> where
    Self: Sized, 

Creates an Adapter that converts each consumption by self to the appropriate G or F.

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 + Display, 

type Good = G

The type of the item being produced.

type Failure = ClosedMarketFailure

The type of the error that could be thrown during production.

fn produce(&self, good: Self::Good) -> Result<(), ProduceError<Self::Failure>>

Stores good in the market without blocking.

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

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

fn force(&self, good: Self::Good) -> Result<(), Self::Failure> where
    Self::Good: Clone + Debug + Display, 

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

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

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