pub type CanonStateNotificationSender<N = EthPrimitives> = Sender<CanonStateNotification<N>>;Expand description
Type alias for a sender that sends CanonStateNotification
Aliased Type§
struct CanonStateNotificationSender<N = EthPrimitives> { /* private fields */ }Layout§
Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.
Size: 8 bytes
Implementations
§impl<T> Sender<T>
impl<T> Sender<T>
pub fn new(capacity: usize) -> Sender<T>
pub fn new(capacity: usize) -> Sender<T>
Creates the sending-half of the broadcast channel.
See the documentation of broadcast::channel for more information on this method.
pub fn send(&self, value: T) -> Result<usize, SendError<T>>
pub fn send(&self, value: T) -> Result<usize, SendError<T>>
Attempts to send a value to all active Receiver handles, returning
it back if it could not be sent.
A successful send occurs when there is at least one active Receiver
handle. An unsuccessful send would be one where all associated
Receiver handles have already been dropped.
§Return
On success, the number of subscribed Receiver handles is returned.
This does not mean that this number of receivers will see the message as
a receiver may drop or lag (see lagging) before receiving
the message.
§Note
A return value of Ok does not mean that the sent value will be
observed by all or any of the active Receiver handles. Receiver
handles may be dropped before receiving the sent message.
A return value of Err does not mean that future calls to send
will fail. New Receiver handles may be created by calling
subscribe.
§Examples
use tokio::sync::broadcast;
#[tokio::main]
async fn main() {
let (tx, mut rx1) = broadcast::channel(16);
let mut rx2 = tx.subscribe();
tokio::spawn(async move {
assert_eq!(rx1.recv().await.unwrap(), 10);
assert_eq!(rx1.recv().await.unwrap(), 20);
});
tokio::spawn(async move {
assert_eq!(rx2.recv().await.unwrap(), 10);
assert_eq!(rx2.recv().await.unwrap(), 20);
});
tx.send(10).unwrap();
tx.send(20).unwrap();
}pub fn subscribe(&self) -> Receiver<T>
pub fn subscribe(&self) -> Receiver<T>
Creates a new [Receiver] handle that will receive values sent after
this call to subscribe.
§Examples
use tokio::sync::broadcast;
#[tokio::main]
async fn main() {
let (tx, _rx) = broadcast::channel(16);
// Will not be seen
tx.send(10).unwrap();
let mut rx = tx.subscribe();
tx.send(20).unwrap();
let value = rx.recv().await.unwrap();
assert_eq!(20, value);
}pub fn downgrade(&self) -> WeakSender<T>
pub fn downgrade(&self) -> WeakSender<T>
Converts the Sender to a [WeakSender] that does not count
towards RAII semantics, i.e. if all Sender instances of the
channel were dropped and only WeakSender instances remain,
the channel is closed.
pub fn len(&self) -> usize
pub fn len(&self) -> usize
Returns the number of queued values.
A value is queued until it has either been seen by all receivers that were alive at the time it was sent, or has been evicted from the queue by subsequent sends that exceeded the queue’s capacity.
§Note
In contrast to [Receiver::len], this method only reports queued values and not values that
have been evicted from the queue before being seen by all receivers.
§Examples
use tokio::sync::broadcast;
#[tokio::main]
async fn main() {
let (tx, mut rx1) = broadcast::channel(16);
let mut rx2 = tx.subscribe();
tx.send(10).unwrap();
tx.send(20).unwrap();
tx.send(30).unwrap();
assert_eq!(tx.len(), 3);
rx1.recv().await.unwrap();
// The len is still 3 since rx2 hasn't seen the first value yet.
assert_eq!(tx.len(), 3);
rx2.recv().await.unwrap();
assert_eq!(tx.len(), 2);
}pub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
Returns true if there are no queued values.
§Examples
use tokio::sync::broadcast;
#[tokio::main]
async fn main() {
let (tx, mut rx1) = broadcast::channel(16);
let mut rx2 = tx.subscribe();
assert!(tx.is_empty());
tx.send(10).unwrap();
assert!(!tx.is_empty());
rx1.recv().await.unwrap();
// The queue is still not empty since rx2 hasn't seen the value.
assert!(!tx.is_empty());
rx2.recv().await.unwrap();
assert!(tx.is_empty());
}pub fn receiver_count(&self) -> usize
pub fn receiver_count(&self) -> usize
Returns the number of active receivers.
An active receiver is a Receiver handle returned from channel or
subscribe. These are the handles that will receive values sent on
this Sender.
§Note
It is not guaranteed that a sent message will reach this number of
receivers. Active receivers may never call recv again before
dropping.
§Examples
use tokio::sync::broadcast;
#[tokio::main]
async fn main() {
let (tx, _rx1) = broadcast::channel(16);
assert_eq!(1, tx.receiver_count());
let mut _rx2 = tx.subscribe();
assert_eq!(2, tx.receiver_count());
tx.send(10).unwrap();
}pub fn same_channel(&self, other: &Sender<T>) -> bool
pub fn same_channel(&self, other: &Sender<T>) -> bool
Returns true if senders belong to the same channel.
§Examples
use tokio::sync::broadcast;
#[tokio::main]
async fn main() {
let (tx, _rx) = broadcast::channel::<()>(16);
let tx2 = tx.clone();
assert!(tx.same_channel(&tx2));
let (tx3, _rx3) = broadcast::channel::<()>(16);
assert!(!tx3.same_channel(&tx2));
}pub async fn closed(&self)
pub async fn closed(&self)
A future which completes when the number of [Receiver]s subscribed to this Sender reaches
zero.
§Examples
use futures::FutureExt;
use tokio::sync::broadcast;
#[tokio::main]
async fn main() {
let (tx, mut rx1) = broadcast::channel::<u32>(16);
let mut rx2 = tx.subscribe();
let _ = tx.send(10);
assert_eq!(rx1.recv().await.unwrap(), 10);
drop(rx1);
assert!(tx.closed().now_or_never().is_none());
assert_eq!(rx2.recv().await.unwrap(), 10);
drop(rx2);
assert!(tx.closed().now_or_never().is_some());
}pub fn strong_count(&self) -> usize
pub fn strong_count(&self) -> usize
Returns the number of [Sender] handles.
pub fn weak_count(&self) -> usize
pub fn weak_count(&self) -> usize
Returns the number of [WeakSender] handles.