Struct async_channel::Sender
source · pub struct Sender<T> { /* private fields */ }
Expand description
The sending side of a channel.
Senders can be cloned and shared among threads. When all senders associated with a channel are dropped, the channel becomes closed.
The channel can also be closed manually by calling Sender::close()
.
Implementations§
source§impl<T> Sender<T>
impl<T> Sender<T>
sourcepub fn try_send(&self, msg: T) -> Result<(), TrySendError<T>>
pub fn try_send(&self, msg: T) -> Result<(), TrySendError<T>>
Attempts to send a message into the channel.
If the channel is full or closed, this method returns an error.
§Examples
use async_channel::{bounded, TrySendError};
let (s, r) = bounded(1);
assert_eq!(s.try_send(1), Ok(()));
assert_eq!(s.try_send(2), Err(TrySendError::Full(2)));
drop(r);
assert_eq!(s.try_send(3), Err(TrySendError::Closed(3)));
sourcepub fn send(&self, msg: T) -> Send<'_, T> ⓘ
pub fn send(&self, msg: T) -> Send<'_, T> ⓘ
Sends a message into the channel.
If the channel is full, this method waits until there is space for a message.
If the channel is closed, this method returns an error.
§Examples
use async_channel::{unbounded, SendError};
let (s, r) = unbounded();
assert_eq!(s.send(1).await, Ok(()));
drop(r);
assert_eq!(s.send(2).await, Err(SendError(2)));
sourcepub fn send_blocking(&self, msg: T) -> Result<(), SendError<T>>
pub fn send_blocking(&self, msg: T) -> Result<(), SendError<T>>
Sends a message into this channel using the blocking strategy.
If the channel is full, this method will block until there is room. If the channel is closed, this method returns an error.
§Blocking
Rather than using asynchronous waiting, like the send
method,
this method will block the current thread until the message is sent.
This method should not be used in an asynchronous context. It is intended to be used such that a channel can be used in both asynchronous and synchronous contexts. Calling this method in an asynchronous context may result in deadlocks.
§Examples
use async_channel::{unbounded, SendError};
let (s, r) = unbounded();
assert_eq!(s.send_blocking(1), Ok(()));
drop(r);
assert_eq!(s.send_blocking(2), Err(SendError(2)));
sourcepub fn force_send(&self, msg: T) -> Result<Option<T>, SendError<T>>
pub fn force_send(&self, msg: T) -> Result<Option<T>, SendError<T>>
Forcefully push a message into this channel.
If the channel is full, this method will replace an existing message in the
channel and return it as Ok(Some(value))
. If the channel is closed, this
method will return an error.
§Examples
use async_channel::{bounded, SendError};
let (s, r) = bounded(3);
assert_eq!(s.send(1).await, Ok(()));
assert_eq!(s.send(2).await, Ok(()));
assert_eq!(s.force_send(3), Ok(None));
assert_eq!(s.force_send(4), Ok(Some(1)));
assert_eq!(r.recv().await, Ok(2));
assert_eq!(r.recv().await, Ok(3));
assert_eq!(r.recv().await, Ok(4));
sourcepub fn close(&self) -> bool
pub fn close(&self) -> bool
Closes the channel.
Returns true
if this call has closed the channel and it was not closed already.
The remaining messages can still be received.
§Examples
use async_channel::{unbounded, RecvError};
let (s, r) = unbounded();
assert_eq!(s.send(1).await, Ok(()));
assert!(s.close());
assert_eq!(r.recv().await, Ok(1));
assert_eq!(r.recv().await, Err(RecvError));
sourcepub fn is_closed(&self) -> bool
pub fn is_closed(&self) -> bool
Returns true
if the channel is closed.
§Examples
use async_channel::{unbounded, RecvError};
let (s, r) = unbounded::<()>();
assert!(!s.is_closed());
drop(r);
assert!(s.is_closed());
sourcepub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
Returns true
if the channel is empty.
§Examples
use async_channel::unbounded;
let (s, r) = unbounded();
assert!(s.is_empty());
s.send(1).await;
assert!(!s.is_empty());
sourcepub fn is_full(&self) -> bool
pub fn is_full(&self) -> bool
Returns true
if the channel is full.
Unbounded channels are never full.
§Examples
use async_channel::bounded;
let (s, r) = bounded(1);
assert!(!s.is_full());
s.send(1).await;
assert!(s.is_full());
sourcepub fn len(&self) -> usize
pub fn len(&self) -> usize
Returns the number of messages in the channel.
§Examples
use async_channel::unbounded;
let (s, r) = unbounded();
assert_eq!(s.len(), 0);
s.send(1).await;
s.send(2).await;
assert_eq!(s.len(), 2);
sourcepub fn capacity(&self) -> Option<usize>
pub fn capacity(&self) -> Option<usize>
Returns the channel capacity if it’s bounded.
§Examples
use async_channel::{bounded, unbounded};
let (s, r) = bounded::<i32>(5);
assert_eq!(s.capacity(), Some(5));
let (s, r) = unbounded::<i32>();
assert_eq!(s.capacity(), None);
sourcepub fn receiver_count(&self) -> usize
pub fn receiver_count(&self) -> usize
Returns the number of receivers for the channel.
§Examples
use async_channel::unbounded;
let (s, r) = unbounded::<()>();
assert_eq!(s.receiver_count(), 1);
let r2 = r.clone();
assert_eq!(s.receiver_count(), 2);
sourcepub fn sender_count(&self) -> usize
pub fn sender_count(&self) -> usize
Returns the number of senders for the channel.
§Examples
use async_channel::unbounded;
let (s, r) = unbounded::<()>();
assert_eq!(s.sender_count(), 1);
let s2 = s.clone();
assert_eq!(s.sender_count(), 2);
sourcepub fn downgrade(&self) -> WeakSender<T>
pub fn downgrade(&self) -> WeakSender<T>
Downgrade the sender to a weak reference.