Struct Sender 

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

Allows sending data to the SPSC channel via its BulkConsumer implementation.

Implementations

impl<R: Deref<Target = State<Q, F, E>>, Q: Queue, F, E> Sender<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 cause_error(&mut self, err: E)

Sets an error to be emitted on the corresponding Receiver. The error is only emitted there when trying to produce values via produce or expose_items (or any method calling one of these), but never when slurping or calling consider_produced.

Must not call any of the Consumer, BufferedConsumer, or BulkProducer methods on this Receiver after calling this function, nor close_sync. May call this function at most once per Receiver. Must not call this function after calling close or close_sync.

pub fn close_sync(&mut self, fin: F)

Same as calling Consumer::close, but sync. Must not use this multiple times, after calling close, or after calling cause_error.

pub fn is_receiver_dropped(&self) -> bool

Returns whether the correponding Receiver has been dropped already.

Trait Implementations

impl<R: Deref<Target = State<Q, F, E>>, Q: Queue, F, E> BufferedConsumer for Sender<R, Q, F, E>

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

Forces the consumer to perform any side-effects that were delayed for previously consumed items.

impl<R: Deref<Target = State<Q, F, E>>, Q: Queue, F, E> BulkConsumer for Sender<R, Q, F, E>

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

where Self::Item: 'a,

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

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

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

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

where Self::Item: Clone,

Consumes a non-zero number of items by reading them from a given buffer and returning how many items were consumed.

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

where Self::Item: Clone,

Tries to bulk-consume (copies of) all items in the given slice. Reports an error if the slice could not be consumed completely.

impl<R: Deref<Target = State<Q, F, E>>, Q: Queue, F, E> Consumer for Sender<R, Q, F, E>

async fn consume(&mut self, item_: Self::Item) -> Result<(), Self::Error>

Writes the item into the buffer queue, waiting for buffer space to become available (by reading items from the corresponding Sender) if necessary.

type Item = <Q as Queue>::Item

The sequence consumed by this consumer starts with arbitrarily many values of this type.

type Final = F

The sequence consumed by this consumer ends with up to one value of this type.

type Error = Infallible

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

async fn close(&mut self, fin: Self::Final) -> Result<(), Self::Error>

Attempts to consume the final item.

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

where Self::Item: Clone,

Tries to consume (clones of) all items in the given slice. Reports an error if the slice could not be consumed completely.

impl<R: Debug + Deref<Target = State<Q, F, E>>, Q: Debug, F: Debug, E: Debug> Debug for Sender<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 Sender<R, Q, F, E>

fn drop(&mut self)

Executes the destructor for this type.