Struct futures_intrusive::channel::shared::GenericReceiver

pub struct GenericReceiver<MutexType, T, A> where
    MutexType: RawMutex,
    A: RingBuf<Item = T>,
    T: 'static,  { /* private fields */ }

The receiving side of a channel which can be used to exchange values between concurrent tasks.

Tasks can receive values from the channel through the receive method. The returned Future will get resolved when a value is sent into the channel.

Implementations

impl<MutexType, T, A> GenericReceiver<MutexType, T, A> where
    MutexType: 'static + RawMutex,
    A: 'static + RingBuf<Item = T>, 

pub fn receive(&self) -> ChannelReceiveFuture<MutexType, T>

Returns a future that gets fulfilled when a value is written to the channel. If the channels gets closed, the future will resolve to None.

pub fn try_receive(&self) -> Result<T, TryReceiveError>

Attempt to receive form the channel without waiting.

pub fn close(&self) -> CloseStatus

Closes the channel. All pending future send attempts will fail. Receive attempts will continue to succeed as long as there are items stored inside the channel. Further attempts will return None.

pub fn into_stream(self) -> SharedStream<MutexType, T, A>

Returns a stream that will receive values from this channel.

This stream does not yield None when the channel is empty, instead it yields None when it is terminated.

Trait Implementations

impl<MutexType, T, A> Clone for GenericReceiver<MutexType, T, A> where
    MutexType: RawMutex,
    A: RingBuf<Item = T>, 

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<MutexType, T, A> Debug for GenericReceiver<MutexType, T, A> where
    MutexType: RawMutex,
    A: RingBuf<Item = T>, 

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

Formats the value using the given formatter.

impl<MutexType, T, A> Drop for GenericReceiver<MutexType, T, A> where
    MutexType: RawMutex,
    A: RingBuf<Item = T>, 

fn drop(&mut self)

Executes the destructor for this type.