Struct MonitorSynchronousProxy

pub struct MonitorSynchronousProxy { /* private fields */ }

Implementations

impl MonitorSynchronousProxy

pub fn new(channel: Channel) -> Self

pub fn into_channel(self) -> Channel

pub fn wait_for_event( &self, deadline: MonotonicInstant, ) -> Result<MonitorEvent, Error>

Waits until an event arrives and returns it. It is safe for other threads to make concurrent requests while waiting for an event.

pub fn set_options(&self, payload: &MonitorOptions) -> Result<(), Error>

Controls verbosity of results returned from calls to [Watch]. If options are set via this method, it must be in the first call made over the channel.

Calling this method after either it or [Watch] have already been invoked will result in closing the channel. If this method is not called before calling [Watch], Snapshot responses will not be modified.

pub fn watch(&self, ___deadline: MonotonicInstant) -> Result<Snapshot, Error>

Hanging-get API for changes in network reachability state.

Watch returns a snapshot of the system’s most recent reachability state information. The first call returns a current snapshot. Subsequent calls to Watch block until the previously-observed state changes.

While this API guarantees that any state returned was a valid network state at some point, it does not guarantee observation of every intermediate state.

It is not valid to call Watch concurrently. Calling Watch while another call over the same server end is in flight will result in the closing the channel.

• response a snapshot of current system reachability state.

Trait Implementations

impl Debug for MonitorSynchronousProxy

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

Formats the value using the given formatter.

impl SynchronousProxy for MonitorSynchronousProxy

type Proxy = MonitorProxy

The async proxy for the same protocol.

type Protocol = MonitorMarker

The protocol which this Proxy controls.

fn from_channel(inner: Channel) -> Self

Create a proxy over the given channel.

fn into_channel(self) -> Channel

Convert the proxy back into a channel.

fn as_channel(&self) -> &Channel

Get a reference to the proxy’s underlying channel.

fn is_closed(&self) -> Result<bool, Status>

Returns true if the proxy has received the PEER_CLOSED signal.