Struct async_broadcast::Sender [−][src]
pub struct Sender<T> { /* fields omitted */ }
Expand description
The sending side of the broadcast 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
Returns the channel capacity.
Examples
use async_broadcast::broadcast; let (s, r) = broadcast::<i32>(5); assert_eq!(s.capacity(), 5);
Set the channel capacity.
There are times when you need to change the channel’s capacity after creating it. If the
new_cap
is less than the number of messages in the channel, the oldest messages will be
dropped to shrink the channel.
Examples
use async_broadcast::{broadcast, TrySendError, TryRecvError}; let (mut s, mut r) = broadcast::<i32>(3); assert_eq!(s.capacity(), 3); s.try_broadcast(1).unwrap(); s.try_broadcast(2).unwrap(); s.try_broadcast(3).unwrap(); s.set_capacity(1); assert_eq!(s.capacity(), 1); assert_eq!(r.try_recv().unwrap(), 3); assert_eq!(r.try_recv(), Err(TryRecvError::Empty)); s.try_broadcast(1).unwrap(); assert_eq!(s.try_broadcast(2), Err(TrySendError::Full(2))); s.set_capacity(2); assert_eq!(s.capacity(), 2); s.try_broadcast(2).unwrap(); assert_eq!(s.try_broadcast(2), Err(TrySendError::Full(2)));
If overflow mode is enabled on this channel.
Examples
use async_broadcast::broadcast; let (s, r) = broadcast::<i32>(5); assert!(!s.overflow());
Set overflow mode on the channel.
When overflow mode is set, broadcasting to the channel will succeed even if the channel is full. It achieves that by removing the oldest message from the channel.
Examples
use async_broadcast::{broadcast, TrySendError, TryRecvError}; let (mut s, mut r) = broadcast::<i32>(2); s.try_broadcast(1).unwrap(); s.try_broadcast(2).unwrap(); assert_eq!(s.try_broadcast(3), Err(TrySendError::Full(3))); s.set_overflow(true); assert_eq!(s.try_broadcast(3).unwrap(), Some(1)); assert_eq!(s.try_broadcast(4).unwrap(), Some(2)); assert_eq!(r.try_recv().unwrap(), 3); assert_eq!(r.try_recv().unwrap(), 4); assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
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_broadcast::{broadcast, RecvError}; let (s, mut r) = broadcast(1); s.broadcast(1).await.unwrap(); assert!(s.close()); assert_eq!(r.recv().await.unwrap(), 1); assert_eq!(r.recv().await, Err(RecvError));
Returns true
if the channel is closed.
Examples
use async_broadcast::{broadcast, RecvError}; let (s, r) = broadcast::<()>(1); assert!(!s.is_closed()); drop(r); assert!(s.is_closed());
Returns true
if the channel is empty.
Examples
use async_broadcast::broadcast; let (s, r) = broadcast(1); assert!(s.is_empty()); s.broadcast(1).await; assert!(!s.is_empty());
Returns true
if the channel is full.
Examples
use async_broadcast::broadcast; let (s, r) = broadcast(1); assert!(!s.is_full()); s.broadcast(1).await; assert!(s.is_full());
Returns the number of messages in the channel.
Examples
use async_broadcast::broadcast; let (s, r) = broadcast(2); assert_eq!(s.len(), 0); s.broadcast(1).await; s.broadcast(2).await; assert_eq!(s.len(), 2);
Returns the number of receivers for the channel.
This does not include inactive receivers. Use Sender::inactive_receiver_count
if you
are interested in that.
Examples
use async_broadcast::broadcast; let (s, r) = broadcast::<()>(1); assert_eq!(s.receiver_count(), 1); let r = r.deactivate(); assert_eq!(s.receiver_count(), 0); let r2 = r.activate_cloned(); assert_eq!(r.receiver_count(), 1); assert_eq!(r.inactive_receiver_count(), 1);
Returns the number of inactive receivers for the channel.
Examples
use async_broadcast::broadcast; let (s, r) = broadcast::<()>(1); assert_eq!(s.receiver_count(), 1); let r = r.deactivate(); assert_eq!(s.receiver_count(), 0); let r2 = r.activate_cloned(); assert_eq!(r.receiver_count(), 1); assert_eq!(r.inactive_receiver_count(), 1);
Returns the number of senders for the channel.
Examples
use async_broadcast::broadcast; let (s, r) = broadcast::<()>(1); assert_eq!(s.sender_count(), 1); let s2 = s.clone(); assert_eq!(s.sender_count(), 2);
Broadcasts a message on the channel.
If the channel is full, this method waits until there is space for a message unless overflow
mode (set through Sender::set_overflow
) is enabled. If the overflow mode is enabled it
removes the oldest message from the channel to make room for the new message. The removed
message is returned to the caller.
If the channel is closed, this method returns an error.
Examples
use async_broadcast::{broadcast, SendError}; let (s, r) = broadcast(1); assert_eq!(s.broadcast(1).await, Ok(None)); drop(r); assert_eq!(s.broadcast(2).await, Err(SendError(2)));
Attempts to broadcast a message on the channel.
If the channel is full, this method returns an error unless overflow mode (set through
Sender::set_overflow
) is enabled. If the overflow mode is enabled, it removes the
oldest message from the channel to make room for the new message. The removed message
is returned to the caller.
If the channel is closed, this method returns an error.
Examples
use async_broadcast::{broadcast, TrySendError}; let (s, r) = broadcast(1); assert_eq!(s.try_broadcast(1), Ok(None)); assert_eq!(s.try_broadcast(2), Err(TrySendError::Full(2))); drop(r); assert_eq!(s.try_broadcast(3), Err(TrySendError::Closed(3)));
Trait Implementations
Auto Trait Implementations
impl<T> RefUnwindSafe for Sender<T>
impl<T> UnwindSafe for Sender<T>
Blanket Implementations
Mutably borrows from an owned value. Read more