Struct MAsyncRx 

pub struct MAsyncRx<T>(/* private fields */);

A multi-consumer (receiver) that works in an async context.

Inherits from AsyncRx<T> and implements Clone. Additional methods in ChannelShared can be accessed through Deref.

You can use into() to convert it to AsyncRx<T>.

MAsyncRx can be converted into MRx via the From trait, which means you can have two types of receivers, both within async and blocking contexts, for the same channel.

Implementations

impl<T> MAsyncRx<T>

pub fn into_stream(self) -> AsyncStream<T>

where T: Send + Unpin + 'static,

pub fn into_blocking(self) -> MRx<T>

Methods from Deref<Target = AsyncRx<T>>

pub fn recv<'a>(&'a self) -> RecvFuture<'a, T>

Receives a message from the channel. This method will await until a message is received or the channel is closed.

This function is cancellation-safe, so it’s safe to use with timeout() and the select! macro. When a RecvFuture is dropped, no message will be received from the channel.

For timeout scenarios, there’s an alternative: AsyncRx::recv_timeout().

Returns Ok(T) on success.

Returns Err(RecvError) if the sender has been dropped.

pub fn recv_timeout<'a>( &'a self, duration: Duration, ) -> RecvTimeoutFuture<'a, T, ()>

Available on crate features tokio or async_std only.

Receives a message from the channel with a timeout. Will await when channel is empty.

The behavior is atomic: the message is either received successfully or the operation is canceled due to a timeout.

Returns Ok(T) when successful.

Returns Err(RecvTimeoutError::Timeout) when a message could not be received because the channel is empty and the operation timed out.

Returns Err(RecvTimeoutError::Disconnected) if the sender has been dropped and the channel is empty.

pub fn recv_with_timer<'a, F, R>( &'a self, fut: F, ) -> RecvTimeoutFuture<'a, T, R>

where F: Future<Output = R> + 'static,

Receives a message from the channel with a custom timer function (from other async runtime).

The behavior is atomic: the message is either received successfully or the operation is canceled due to a timeout.

Returns Ok(T) when successful.

Returns Err(RecvTimeoutError::Timeout) when a message could not be received because the channel is empty and the operation timed out.

Returns Err(RecvTimeoutError::Disconnected) if the sender has been dropped and the channel is empty.

Argument:

• fut: The sleep function. It’s possible to wrap this function with cancelable handle, you can control when to stop polling. the return value of fut is ignore. We add generic R just in order to support smol::Timer

Example:

extern crate smol;
use std::time::Duration;
use crossfire::*;
async fn foo() {
    let (tx, rx) = mpmc::bounded_async::<usize>(10);
    match rx.recv_with_timer(smol::Timer::after(Duration::from_secs(1))).await {
        Ok(_item)=>{
            println!("message recv");
        }
        Err(RecvTimeoutError::Timeout)=>{
            println!("timeout");
        }
        Err(RecvTimeoutError::Disconnected)=>{
            println!("sender-side closed");
        }
    }
}

pub fn try_recv(&self) -> Result<T, TryRecvError>

Attempts to receive a message from the channel without blocking.

Returns Ok(T) on successful.

Returns Err(TryRecvError::Empty) if the channel is empty.

Returns Err(TryRecvError::Disconnected) if the sender has been dropped and the channel is empty.

Methods from Deref<Target = ChannelShared<T>>

pub fn len(&self) -> usize

The number of messages in the channel.

pub fn capacity(&self) -> Option<usize>

The capacity of the channel. Returns None for unbounded channels.

pub fn is_empty(&self) -> bool

Returns true if the channel is empty.

pub fn is_full(&self) -> bool

Returns true if the channel is full.

pub fn is_disconnected(&self) -> bool

Returns true if all senders or receivers have been dropped.

pub fn get_tx_count(&self) -> usize

Returns the number of senders for the channel.

pub fn get_rx_count(&self) -> usize

Returns the number of receivers for the channel.

pub fn get_wakers_count(&self) -> (usize, usize)

Returns the number of wakers for senders and receivers. For debugging purposes.

Trait Implementations

impl<T> AsRef<ChannelShared<T>> for MAsyncRx<T>

fn as_ref(&self) -> &ChannelShared<T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Unpin + Send + 'static> AsyncRxTrait<T> for MAsyncRx<T>

fn clone_to_vec(self, count: usize) -> Vec<Self>

fn try_recv(&self) -> Result<T, TryRecvError>

Try to receive message, non-blocking.

fn recv<'a>(&'a self) -> RecvFuture<'a, T>

Receive message, will await when channel is empty.

fn recv_timeout<'a>( &'a self, duration: Duration, ) -> RecvTimeoutFuture<'a, T, ()>

Available on crate features tokio or async_std only.

Waits for a message to be received from the channel, but only for a limited time. Will await when channel is empty.

fn recv_with_timer<'a, F, R>(&'a self, fut: F) -> RecvTimeoutFuture<'a, T, R>

where F: Future<Output = R> + 'static,

Receives a message from the channel with a custom timer function (from other async runtime).

fn len(&self) -> usize

The number of messages in the channel at the moment

fn capacity(&self) -> Option<usize>

The capacity of the channel, return None for unbounded channel.

fn is_empty(&self) -> bool

Whether channel is empty at the moment

fn is_full(&self) -> bool

Whether the channel is full at the moment

fn is_disconnected(&self) -> bool

Return true if the other side has closed

impl<T> Clone for MAsyncRx<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for MAsyncRx<T>

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

Formats the value using the given formatter.

impl<T> Deref for MAsyncRx<T>

fn deref(&self) -> &Self::Target

inherit all the functions of AsyncRx

type Target = AsyncRx<T>

The resulting type after dereferencing.

impl<T> Display for MAsyncRx<T>

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

Formats the value using the given formatter.

impl<T> From<MAsyncRx<T>> for AsyncRx<T>

fn from(rx: MAsyncRx<T>) -> Self

Converts to this type from the input type.

impl<T: Unpin + Send + 'static> From<MAsyncRx<T>> for AsyncStream<T>

fn from(rx: MAsyncRx<T>) -> Self

Converts to this type from the input type.

impl<T> From<MAsyncRx<T>> for MRx<T>

fn from(value: MAsyncRx<T>) -> Self

Converts to this type from the input type.

impl<T> From<MRx<T>> for MAsyncRx<T>

fn from(value: MRx<T>) -> Self

Converts to this type from the input type.

impl<T: Send> Sync for MAsyncRx<T>