Enum Sender 

pub enum Sender<T> {
    Tokio(Sender<T>),
    Boxed(Arc<dyn DynSender<T>>),
}

Single producer, single consumer sender.

For the local case, this wraps a tokio::sync::mpsc::Sender.

Variants

Tokio(Sender<T>)

Boxed(Arc<dyn DynSender<T>>)

Implementations

impl<T> Sender<T>

pub fn is_rpc(&self) -> bool

where T: 'static,

pub fn into_sink(self) -> impl Sink<T, Error = SendError> + Send + 'static

where T: Send + Sync + 'static,

Available on crate feature stream only.

impl<T: Send + Sync + 'static> Sender<T>

pub fn with_filter<F>(self, f: F) -> Sender<T>

where F: Fn(&T) -> bool + Send + Sync + 'static,

Applies a filter before sending.

Messages that don’t pass the filter are dropped.

If you want to combine multiple filters and maps with minimal overhead, use with_filter_map directly.

pub fn with_map<U, F>(self, f: F) -> Sender<U>

where F: Fn(U) -> T + Send + Sync + 'static, U: Send + Sync + 'static,

Applies a transform before sending.

If you want to combine multiple filters and maps with minimal overhead, use with_filter_map directly.

pub fn with_filter_map<U, F>(self, f: F) -> Sender<U>

where F: Fn(U) -> Option<T> + Send + Sync + 'static, U: Send + Sync + 'static,

Applies a filter and transform before sending.

Any combination of filters and maps can be expressed using a single filter_map.

pub async fn closed(&self)

Future that resolves when the sender is closed

impl<T: Send + 'static> Sender<T>

pub async fn send(&self, value: T) -> Result<(), SendError>

Send a message and yield until either it is sent or an error occurs.

Cancellation safety

If the future is dropped before completion, and if this is a remote sender, then the sender will be closed and further sends will return an SendError::Io with std::io::ErrorKind::BrokenPipe. Therefore, make sure to always poll the future until completion if you want to reuse the sender or any clone afterwards.

pub async fn try_send(&self, value: T) -> Result<bool, SendError>

Try to send a message, returning as fast as possible if sending is not currently possible. This can be used to send ephemeral messages.

For the local case, this will immediately return false if the channel is full.

For the remote case, it will attempt to send the message and return false if sending the first byte fails, otherwise yield until the message is completely sent or an error occurs. This guarantees that the message is sent either completely or not at all.

Returns true if the message was sent.

Cancellation safety

If the future is dropped before completion, and if this is a remote sender, then the sender will be closed and further sends will return an SendError::Io with std::io::ErrorKind::BrokenPipe. Therefore, make sure to always poll the future until completion if you want to reuse the sender or any clone afterwards.

Trait Implementations

impl<T> Clone for Sender<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 Sender<T>

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

Formats the value using the given formatter.

impl<T: RpcMessage> From<SendStream> for Sender<T>

Available on crate feature rpc only.

fn from(write: SendStream) -> Self

Converts to this type from the input type.

impl<S: Service> From<Sender<<S as Service>::Message>> for LocalSender<S>

fn from(tx: Sender<S::Message>) -> Self

Converts to this type from the input type.

impl<T> From<Sender<T>> for Sender<T>

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

Converts to this type from the input type.

impl<T> TryFrom<Sender<T>> for Sender<T>

type Error = Sender<T>

The type returned in the event of a conversion error.

fn try_from(value: Sender<T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T> Sender for Sender<T>