Struct Subscription 

pub struct Subscription<T> { /* private fields */ }

A Subscription is a feed of notifications from the server of a specific type T, identified by a local ID.

For flexibility, we expose three similar APIs:

• The Subscription::recv method and its variants will discard any notifications of unexpected types.
• The Subscription::recv_any and its variants will yield unexpected types as SubscriptionItem::Other.
• The Subscription::recv_result and its variants will attempt to deserialize the notifications and yield the serde_json::Result of the deserialization.

Implementations

impl<T> Subscription<T>

pub const fn local_id(&self) -> &B256

Get the local ID of the subscription.

pub fn into_raw(self) -> RawSubscription

Convert the subscription into its inner RawSubscription.

pub const fn inner(&self) -> &RawSubscription

Get a reference to the inner subscription.

pub const fn inner_mut(&mut self) -> &mut RawSubscription

Get a mutable reference to the inner subscription.

pub fn is_empty(&self) -> bool

Returns true if the broadcast channel is empty (i.e. there are currently no notifications to receive).

pub fn len(&self) -> usize

Returns the number of messages in the broadcast channel that this receiver has yet to receive.

NB: This count may include messages of unexpected types that will be discarded upon receipt.

pub fn resubscribe_inner(&self) -> RawSubscription

Wrapper for resubscribe. Create a new RawSubscription, starting from the current tail element.

pub fn resubscribe(&self) -> Self

Wrapper for resubscribe. Create a new Subscription, starting from the current tail element.

pub fn same_channel<U>(&self, other: &Subscription<U>) -> bool

Wrapper for same_channel. Returns true if the two subscriptions share the same broadcast channel.

impl<T: DeserializeOwned> Subscription<T>

pub fn blocking_recv_any(&mut self) -> Result<SubscriptionItem<T>, RecvError>

Wrapper for blocking_recv, may produce unexpected values. Block the current thread until a message is available.

pub async fn recv_any(&mut self) -> Result<SubscriptionItem<T>, RecvError>

Wrapper for recv, may produce unexpected values. Await an item from the channel.

pub fn try_recv_any(&mut self) -> Result<SubscriptionItem<T>, TryRecvError>

Wrapper for try_recv. Attempt to receive a message from the channel without awaiting.

pub fn into_stream(self) -> SubscriptionStream<T>

Convert the subscription into a stream.

Errors are logged and ignored.

pub fn into_result_stream(self) -> SubResultStream<T>

Convert the subscription into a stream that returns deserialization results.

pub fn into_any_stream(self) -> SubAnyStream<T>

Convert the subscription into a stream that may yield unexpected types.

pub fn blocking_recv(&mut self) -> Result<T, RecvError>

Wrapper for blocking_recv. Block the current thread until a message of the expected type is available.

pub async fn recv(&mut self) -> Result<T, RecvError>

Wrapper for recv. Await an item of the expected type from the channel.

pub fn try_recv(&mut self) -> Result<T, TryRecvError>

Wrapper for try_recv. Attempt to receive a message of the expected type from the channel without awaiting.

pub fn blocking_recv_result(&mut self) -> Result<Result<T, Error>, RecvError>

Wrapper for blocking_recv. Block the current thread until a message is available, deserializing the message and returning the result.

pub async fn recv_result(&mut self) -> Result<Result<T, Error>, RecvError>

Wrapper for recv. Await an item from the channel, deserializing the message and returning the result.

pub fn try_recv_result(&mut self) -> Result<Result<T, Error>, TryRecvError>

Wrapper for try_recv. Attempt to receive a message from the channel without awaiting, deserializing the message and returning the result.

Trait Implementations

impl<T: Debug> Debug for Subscription<T>

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

Formats the value using the given formatter.

impl<T> From<RawSubscription> for Subscription<T>

fn from(inner: RawSubscription) -> Self

Converts to this type from the input type.

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: 48 bytes