Struct MAsyncTx 

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

A multi-producer (sender) that works in an async context.

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

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

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

Implementations

impl<T> MAsyncTx<T>

pub fn into_sink(self) -> AsyncSink<T>

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

Methods from Deref<Target = AsyncTx<T>>

pub fn send<'a>(&'a self, item: T) -> SendFuture<'a, T>

Sends a message. This method will await until the message is sent or the channel is closed.

This function is cancellation-safe, so it’s safe to use with timeout() and the select! macro. When a SendFuture is dropped, no message will be sent. However, the original message cannot be returned due to API limitations. For timeout scenarios, we recommend using AsyncTx::send_timeout(), which returns the message in a SendTimeoutError.

Returns Ok(()) on success.

Returns Err(SendError) if the receiver has been dropped.

pub fn try_send(&self, item: T) -> Result<(), TrySendError<T>>

Attempts to send a message without blocking.

Returns Ok(()) when successful.

Returns Err(TrySendError::Full) if the channel is full.

Returns Err(TrySendError::Disconnected) if the receiver has been dropped.

pub fn send_timeout<'a>( &'a self, item: T, duration: Duration, ) -> SendTimeoutFuture<'a, T, ()>

Available on crate features tokio or async_std only.

Sends a message with a timeout. Will await when channel is full.

The behavior is atomic: the message is either sent successfully or returned with error.

Returns Ok(()) when successful.

Returns Err(SendTimeoutError::Timeout) if the operation timed out. The error contains the message that failed to be sent.

Returns Err(SendTimeoutError::Disconnected) if the receiver has been dropped. The error contains the message that failed to be sent.

pub fn send_with_timer<'a, F, R>( &'a self, item: T, fut: F, ) -> SendTimeoutFuture<'a, T, R>

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

Sends a message with a custom timer function (from other async runtime).

The behavior is atomic: the message is either sent successfully or returned with error.

Returns Ok(()) when successful.

Returns Err(SendTimeoutError::Timeout) if the operation timed out. The error contains the message that failed to be sent.

Returns Err(SendTimeoutError::Disconnected) if the receiver has been dropped. The error contains the message that failed to be sent.

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 tx.send_with_timer(1, smol::Timer::after(Duration::from_secs(1))).await {
        Ok(_)=>{
            println!("message sent");
        }
        Err(SendTimeoutError::Timeout(_item))=>{
            println!("send timeout");
        }
        Err(SendTimeoutError::Disconnected(_item))=>{
            println!("receiver-side closed");
        }
    }
}

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 MAsyncTx<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> AsyncTxTrait<T> for MAsyncTx<T>

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

fn try_send(&self, item: T) -> Result<(), TrySendError<T>>

Try to send message, non-blocking

fn send<'a>(&'a self, item: T) -> SendFuture<'a, T>

Send message. Will await when channel is full.

fn send_timeout<'a>( &'a self, item: T, duration: Duration, ) -> SendTimeoutFuture<'a, T, ()>

Available on crate features tokio or async_std only.

Waits for a message to be sent into the channel, but only for a limited time. Will await when channel is full.

fn send_with_timer<'a, F, R>( &'a self, item: T, fut: F, ) -> SendTimeoutFuture<'a, T, R>

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

Sends a message with a custom timer function. Will await when channel is full.

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: Unpin> Clone for MAsyncTx<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 MAsyncTx<T>

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

Formats the value using the given formatter.

impl<T> Deref for MAsyncTx<T>

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

inherit all the functions of AsyncTx

type Target = AsyncTx<T>

The resulting type after dereferencing.

impl<T> Display for MAsyncTx<T>

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

Formats the value using the given formatter.

impl<T: Unpin + Send + 'static> From<MAsyncTx<T>> for AsyncSink<T>

fn from(tx: MAsyncTx<T>) -> Self

Converts to this type from the input type.

impl<T> From<MAsyncTx<T>> for AsyncTx<T>

fn from(tx: MAsyncTx<T>) -> Self

Converts to this type from the input type.

impl<T> From<MAsyncTx<T>> for MTx<T>

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

Converts to this type from the input type.

impl<T> From<MTx<T>> for MAsyncTx<T>

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

Converts to this type from the input type.

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