Struct Receiver 

pub struct Receiver<R: Deref<Target = State<Q, F, E>>, Q, F, E> { /* private fields */ }

Allows receiving data from the SPSC channel via its BulkProducer implementation.

Implementations

impl<R: Deref<Target = State<Q, F, E>>, Q: Queue, F, E> Receiver<R, Q, F, E>

pub fn len(&self) -> usize

Returns the number of items that are currently buffered.

pub fn is_empty(&self) -> bool

Returns whether there are currently no items buffered.

pub fn is_receiver_dropped(&self) -> bool

Returns whether the correponding Sender has been dropped already.

Trait Implementations

impl<R: Deref<Target = State<Q, F, E>>, Q: Queue, F, E> BufferedProducer for Receiver<R, Q, F, E>

async fn slurp(&mut self) -> Result<(), Self::Error>

Asks the producer to prepare some values for yielding.

impl<R: Deref<Target = State<Q, F, E>>, Q: Queue, F, E> BulkProducer for Receiver<R, Q, F, E>

async fn expose_items<'a>( &'a mut self, ) -> Result<Either<&'a [Self::Item], Self::Final>, Self::Error>

where Self::Item: 'a,

A low-level method for producing multiple items at a time. If you are only working with producers (rather than implementing them), you will probably want to ignore this method and use BulkProducer::bulk_produce instead.

async fn consider_produced(&mut self, amount: usize) -> Result<(), Self::Error>

A low-level method for producing multiple items at a time. If you are only working with producers (rather than implementing them), you will probably want to ignore this method and use BulkProducer::bulk_produce instead.

fn bulk_produce( &mut self, buf: &mut [Self::Item], ) -> impl Future<Output = Result<Either<usize, Self::Final>, Self::Error>>

where Self::Item: Clone,

Produces a non-zero number of items by writing them into a given buffer and returning how many items were produced.

fn bulk_overwrite_full_slice( &mut self, buf: &mut [Self::Item], ) -> impl Future<Output = Result<(), ProduceAtLeastError<Self::Final, Self::Error>>>

where Self::Item: Clone,

Tries to completely overwrite a slice with items from a bulk producer. Reports an error if the slice could not be overwritten completely.

impl<R: Debug + Deref<Target = State<Q, F, E>>, Q: Debug, F: Debug, E: Debug> Debug for Receiver<R, Q, F, E>

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

Formats the value using the given formatter.

impl<R: Deref<Target = State<Q, F, E>>, Q, F, E> Drop for Receiver<R, Q, F, E>

fn drop(&mut self)

Executes the destructor for this type.

impl<R: Deref<Target = State<Q, F, E>>, Q: Queue, F, E> Producer for Receiver<R, Q, F, E>

async fn produce( &mut self, ) -> Result<Either<Self::Item, Self::Final>, Self::Error>

Take an item from the buffer queue, waiting for an item to become available (by being consumed by the corresponding Sender) if necessary.

type Item = <Q as Queue>::Item

The sequence produced by this producer starts with arbitrarily many values of this type.

type Final = F

The sequence produced by this producer ends with up to one value of this type.

type Error = E

The type of errors the producer can emit instead of doing its job.

fn produce_item( &mut self, ) -> impl Future<Output = Result<Self::Item, ProduceAtLeastError<Self::Final, Self::Error>>>

Tries to produce a regular item, and reports an error if the final item was produced instead.

fn overwrite_full_slice( &mut self, buf: &mut [Self::Item], ) -> impl Future<Output = Result<(), ProduceAtLeastError<Self::Final, Self::Error>>>

Tries to completely overwrite a slice with items from a producer. Reports an error if the slice could not be overwritten completely.