Struct CapabilitiesSynchronousProxy 

pub struct CapabilitiesSynchronousProxy { /* private fields */ }

Implementations

impl CapabilitiesSynchronousProxy

pub fn new(channel: Channel) -> Self

pub fn into_channel(self) -> Channel

pub fn wait_for_event( &self, deadline: MonotonicInstant, ) -> Result<CapabilitiesEvent, 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 connector_create( &self, connector: EventPair, receiver_client_end: ClientEnd<ReceiverMarker>, ___deadline: MonotonicInstant, ) -> Result<CapabilitiesConnectorCreateResult, Error>

Creates a reference to a new connector capability. When the connector is opened, the channel given to the open call will be sent over receiver_client_end.

Make sure this method returns before passing the handle’s peer to other methods in this API. The creation may not be complete before then.

pub fn dir_connector_create( &self, dir_connector: EventPair, receiver_client_end: ClientEnd<DirReceiverMarker>, ___deadline: MonotonicInstant, ) -> Result<CapabilitiesDirConnectorCreateResult, Error>

Creates a reference to a new directory connector capability. When the directory connector is opened, the channel given to the open call will be sent over receiver_client_end.

Make sure this method returns before passing the handle’s peer to other methods in this API. The creation may not be complete before then.

pub fn dictionary_create( &self, dictionary: EventPair, ___deadline: MonotonicInstant, ) -> Result<CapabilitiesDictionaryCreateResult, Error>

Creates a reference to a new dictionary capability.

Make sure this method returns before passing the handle’s peer to other methods in this API. The creation may not be complete before then.

pub fn data_create( &self, data_handle: EventPair, data: &Data, ___deadline: MonotonicInstant, ) -> Result<CapabilitiesDataCreateResult, Error>

Creates a reference to a new data capability with the given value.

Make sure this method returns before passing the handle’s peer to other methods in this API. The creation may not be complete before then.

pub fn connector_router_create( &self, router: EventPair, router_client_end: ClientEnd<ConnectorRouterMarker>, ___deadline: MonotonicInstant, ) -> Result<CapabilitiesConnectorRouterCreateResult, Error>

Creates a reference to a new router capability that will return a connector capability when used.

Make sure this method returns before passing the handle’s peer to other methods in this API. The creation may not be complete before then.

pub fn dir_connector_router_create( &self, router: EventPair, router_client_end: ClientEnd<DirConnectorRouterMarker>, ___deadline: MonotonicInstant, ) -> Result<CapabilitiesDirConnectorRouterCreateResult, Error>

Creates a reference to a new router capability that will return a directory connector capability when used.

Make sure this method returns before passing the handle’s peer to other methods in this API. The creation may not be complete before then.

pub fn dictionary_router_create( &self, router: EventPair, router_client_end: ClientEnd<DictionaryRouterMarker>, ___deadline: MonotonicInstant, ) -> Result<CapabilitiesDictionaryRouterCreateResult, Error>

Creates a reference to a new router capability that will return a dictionary capability when used.

Make sure this method returns before passing the handle’s peer to other methods in this API. The creation may not be complete before then.

pub fn data_router_create( &self, router: EventPair, router_client_end: ClientEnd<DataRouterMarker>, ___deadline: MonotonicInstant, ) -> Result<CapabilitiesDataRouterCreateResult, Error>

Creates a reference to a new router capability that will return a data value when used.

Make sure this method returns before passing the handle’s peer to other methods in this API. The creation may not be complete before then.

pub fn connector_open( &self, connector: EventPair, channel: Channel, ___deadline: MonotonicInstant, ) -> Result<CapabilitiesConnectorOpenResult, Error>

Uses the provided connector to open a new connection by delivering this channel to whoever created the connector.

If there is an error, it will be reported as a zx.Status epitaph on channel.

If the connector event pair handle is not correlated with a handle given to ConnectorCreate, this connection will be closed.

pub fn dir_connector_open( &self, payload: CapabilitiesDirConnectorOpenRequest, ___deadline: MonotonicInstant, ) -> Result<CapabilitiesDirConnectorOpenResult, Error>

Uses the provided dir_connector to open a new directory connection by delivering this channel to whoever created the directory connector.

If there is an error, it will be reported as a zx.Status epitaph on channel.

If the dir_connector event pair handle is not correlated with a handle given to DirConnectorCreate, this connection will be closed.

dir_connector and channel are both required. rights and subdir may be omitted.

pub fn dictionary_insert( &self, dictionary: EventPair, key: &str, value: EventPair, ___deadline: MonotonicInstant, ) -> Result<CapabilitiesDictionaryInsertResult, Error>

Inserts a new capability into this Dictionary under the name key. Overwrites any existing entry.

pub fn dictionary_get( &self, dictionary: EventPair, key: &str, value: EventPair, ___deadline: MonotonicInstant, ) -> Result<CapabilitiesDictionaryGetResult, Error>

Creates a new reference to the capability named key in this dictionary, if that capability exists. That capability will remain in the dictionary. To take a capability out of the dictionary, use DictionaryRemove.

If key does not exist, value will not reference any capability and the NO_SUCH_CAPABILITY error value will be returned.

Make sure this method returns before passing the handle’s peer to other methods in this API. The creation may not be complete before then.

pub fn dictionary_remove( &self, payload: CapabilitiesDictionaryRemoveRequest, ___deadline: MonotonicInstant, ) -> Result<CapabilitiesDictionaryRemoveResult, Error>

Removes the capability named key from this dictionary and returns a reference to it, if that capability exists.

dictionary and key are required. capability is optional, and when set will become associated with the capability that was removed from the dictionary.

If key does not exist, value will not reference any capability and the NO_SUCH_CAPABILITY error value will be returned.

Make sure this method returns before passing the peer of capability to other methods in this API. The creation may not be complete before then.

pub fn dictionary_iterate_keys( &self, dictionary: EventPair, key_iterator: ServerEnd<DictionaryKeyIteratorMarker>, ___deadline: MonotonicInstant, ) -> Result<CapabilitiesDictionaryIterateKeysResult, Error>

Opens an iterator which can be used to iterate over the keys of this dictionary.

pub fn data_get( &self, data_handle: EventPair, ___deadline: MonotonicInstant, ) -> Result<CapabilitiesDataGetResult, Error>

Returns the Data value that was provided to the DataCreate call used with data_handle.

pub fn connector_router_route( &self, router: EventPair, request: RouteRequest, connector: EventPair, ___deadline: MonotonicInstant, ) -> Result<CapabilitiesConnectorRouterRouteResult, Error>

Attempts to produce a Connector capability from this ConnectorRouter.

Make sure this method returns before passing the peer of capability to other methods in this API. The creation may not be complete before then.

pub fn dir_connector_router_route( &self, router: EventPair, request: RouteRequest, dir_connector: EventPair, ___deadline: MonotonicInstant, ) -> Result<CapabilitiesDirConnectorRouterRouteResult, Error>

Attempts to produce a DirConnector capability from this DirConnectorRouter. This will return:

• A DirConnector if the operation is successful.
• An empty value if there is no issue found but the capability is not being provided (for example, an optional route ended in an offer from void).
• An error, if the operation failed.

pub fn dictionary_router_route( &self, router: EventPair, request: RouteRequest, dictionary: EventPair, ___deadline: MonotonicInstant, ) -> Result<CapabilitiesDictionaryRouterRouteResult, Error>

Attempts to produce a Dictionary capability from this DictionaryRouter. This will return:

• A Dictionary if the operation is successful.
• An empty value if there is no issue found but the capability is not being provided (for example, an optional route ended in an offer from void).
• An error, if the operation failed.

pub fn data_router_route( &self, router: EventPair, request: RouteRequest, data_handle: i32, ___deadline: MonotonicInstant, ) -> Result<CapabilitiesDataRouterRouteResult, Error>

Attempts to produce a Data value from this DataRouter. This will return:

• A Data value if the operation is successful.
• An empty value if there is no issue found but the capability is not being provided (for example, an optional route ended in an offer from void).
• An error, if the operation failed.

Trait Implementations

impl Debug for CapabilitiesSynchronousProxy

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

Formats the value using the given formatter.

impl From<CapabilitiesSynchronousProxy> for Handle

Available on Fuchsia only.

fn from(value: CapabilitiesSynchronousProxy) -> Self

Converts to this type from the input type.

impl From<Channel> for CapabilitiesSynchronousProxy

Available on Fuchsia only.

fn from(value: Channel) -> Self

Converts to this type from the input type.

impl FromClient for CapabilitiesSynchronousProxy

Available on Fuchsia only.

type Protocol = CapabilitiesMarker

The protocol.

fn from_client(value: ClientEnd<CapabilitiesMarker>) -> Self

Converts from a client.

impl SynchronousProxy for CapabilitiesSynchronousProxy

Available on Fuchsia only.

type Proxy = CapabilitiesProxy

The async proxy for the same protocol.

type Protocol = CapabilitiesMarker

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.