Struct AsyncStream 

pub struct AsyncStream<F: Flavor> { /* private fields */ }

Constructed by AsyncRx::into_stream()

Implements futures_core::stream::Stream.

Implementations

impl<F: Flavor> AsyncStream<F>

pub fn new(rx: AsyncRx<F>) -> Self

pub fn poll_item(&mut self, ctx: &mut Context<'_>) -> Poll<Option<F::Item>>

where F::Item: Send + 'static,

poll_item() will try to receive a message. If the channel is empty, it will register a notification for the next poll.

Behavior

The polling behavior is different from RecvFuture. Because the waker is not exposed to the user, you cannot perform delicate operations on the waker (compared to the Drop handler in RecvFuture). To make sure no deadlock happens on cancellation, the WakerState will be Init after being registered (and will not be converted to Waiting). The senders will wake up all Init state wakers until they find a normal pending receiver in the Waiting state.

Return Value:

Returns Ok(T) on success.

Returns Err(TryRecvError::Empty) for a Poll::Pending case. The next time the channel is not empty, your future will be woken again. You should then continue calling poll_item() to receive the message. If you want to cancel, just don’t call poll_item() again. Others will still have a chance to receive messages.

Returns Err(TryRecvError::Disconnected) if all Tx have been dropped and the channel is empty.

Methods from Deref<Target = AsyncRx<F>>

pub fn is_disconnected(&self) -> bool

Return true if the other side has closed

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

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, F, ()>

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, FR, R>( &'a self, fut: FR, ) -> RecvTimeoutFuture<'a, F, R>

where FR: 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<F::Item, 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.

pub fn read_select(&self, result: SelectResult) -> Result<F::Item, RecvError>

where F: FlavorSelect,

This method use with select, guarantee non-blocking

Panics

Panics if SelectResult from other receiver is passed.

Methods from Deref<Target = ChannelShared<F>>

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 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<F: Flavor> Debug for AsyncStream<F>

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

Formats the value using the given formatter.

impl<F: Flavor> Deref for AsyncStream<F>

type Target = AsyncRx<F>

The resulting type after dereferencing.

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

Dereferences the value.

impl<F: Flavor> Display for AsyncStream<F>

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

Formats the value using the given formatter.

impl<F: Flavor> Drop for AsyncStream<F>

fn drop(&mut self)

Executes the destructor for this type.

impl<F: Flavor> From<AsyncRx<F>> for AsyncStream<F>

fn from(rx: AsyncRx<F>) -> Self

Converts to this type from the input type.

impl<F: Flavor> From<MAsyncRx<F>> for AsyncStream<F>

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

Converts to this type from the input type.

impl<F: Flavor> FusedStream for AsyncStream<F>

where F::Item: Send + 'static,

fn is_terminated(&self) -> bool

Returns true if the stream should no longer be polled.

impl<F: Flavor> Stream for AsyncStream<F>

where F::Item: Send + 'static,

type Item = <F as Queue>::Item

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, ctx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.