Struct async_broadcast::InactiveReceiver
source · pub struct InactiveReceiver<T> { /* private fields */ }Expand description
An inactive receiver.
An inactive receiver is a receiver that is unable to receive messages. It’s only useful for keeping a channel open even when no associated active receivers exist.
Implementations§
source§impl<T> InactiveReceiver<T>
impl<T> InactiveReceiver<T>
sourcepub fn activate(self) -> Receiver<T>
pub fn activate(self) -> Receiver<T>
Convert to an activate Receiver.
Consumes self. Use InactiveReceiver::activate_cloned if you want to keep self.
Examples
use async_broadcast::{broadcast, TrySendError};
let (s, r) = broadcast(1);
let inactive = r.deactivate();
assert_eq!(s.try_broadcast(10), Err(TrySendError::Inactive(10)));
let mut r = inactive.activate();
assert_eq!(s.try_broadcast(10), Ok(None));
assert_eq!(r.try_recv(), Ok(10));sourcepub fn activate_cloned(&self) -> Receiver<T>
pub fn activate_cloned(&self) -> Receiver<T>
Create an activate Receiver for the associated channel.
Examples
use async_broadcast::{broadcast, TrySendError};
let (s, r) = broadcast(1);
let inactive = r.deactivate();
assert_eq!(s.try_broadcast(10), Err(TrySendError::Inactive(10)));
let mut r = inactive.activate_cloned();
assert_eq!(s.try_broadcast(10), Ok(None));
assert_eq!(r.try_recv(), Ok(10));sourcepub fn capacity(&self) -> usize
pub fn capacity(&self) -> usize
Returns the channel capacity.
See Receiver::capacity documentation for examples.
sourcepub fn set_capacity(&mut self, new_cap: usize)
pub fn set_capacity(&mut self, new_cap: usize)
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.
See Receiver::set_capacity documentation for examples.
sourcepub fn overflow(&self) -> bool
pub fn overflow(&self) -> bool
If overflow mode is enabled on this channel.
See Receiver::overflow documentation for examples.
sourcepub fn set_overflow(&mut self, overflow: bool)
pub fn set_overflow(&mut self, overflow: bool)
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.
See Receiver::set_overflow documentation for examples.
sourcepub fn await_active(&self) -> bool
pub fn await_active(&self) -> bool
sourcepub fn set_await_active(&mut self, await_active: bool)
pub fn set_await_active(&mut self, await_active: bool)
Specify if sender will wait for active receivers.
If set to false, Send will resolve immediately with a SendError. Defaults to
true.
Examples
use async_broadcast::broadcast;
let (s, r) = broadcast::<i32>(2);
s.broadcast(1).await.unwrap();
let mut r = r.deactivate();
r.set_await_active(false);
assert!(s.broadcast(2).await.is_err());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.
See Receiver::close documentation for examples.
sourcepub fn is_closed(&self) -> bool
pub fn is_closed(&self) -> bool
Returns true if the channel is closed.
See Receiver::is_closed documentation for examples.
sourcepub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
Returns true if the channel is empty.
See Receiver::is_empty documentation for examples.
sourcepub fn is_full(&self) -> bool
pub fn is_full(&self) -> bool
Returns true if the channel is full.
See Receiver::is_full documentation for examples.
sourcepub fn len(&self) -> usize
pub fn len(&self) -> usize
Returns the number of messages in the channel.
See Receiver::len documentation for examples.
sourcepub fn receiver_count(&self) -> usize
pub fn receiver_count(&self) -> usize
Returns the number of receivers for the channel.
This does not include inactive receivers. Use InactiveReceiver::inactive_receiver_count
if you’re 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);sourcepub fn inactive_receiver_count(&self) -> usize
pub fn inactive_receiver_count(&self) -> usize
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);sourcepub fn sender_count(&self) -> usize
pub fn sender_count(&self) -> usize
Returns the number of senders for the channel.
See Receiver::sender_count documentation for examples.