Struct fidl_fuchsia_component_sandbox::DictionaryProxy

pub struct DictionaryProxy { /* private fields */ }

Implementations

impl DictionaryProxy

pub fn new(channel: AsyncChannel) -> Self

Create a new Proxy for fuchsia.component.sandbox/Dictionary.

pub fn take_event_stream(&self) -> DictionaryEventStream

Get a Stream of events from the remote end of the protocol.

Panics

Panics if the event stream was already taken.

pub fn insert( &self, key: &str, value: Capability ) -> QueryResponseFut<DictionaryInsertResult>

Inserts a key-value pair into the dictionary.

• error DictionaryError.ALREADY_EXISTS if the dictionary already contains an item with the same key.

pub fn get(&self, key: &str) -> QueryResponseFut<DictionaryGetResult>

Get a clone of a capability from this dictionary.

• error DictionaryError.NOT_FOUND if the dictionary does not contain the key.

pub fn remove(&self, key: &str) -> QueryResponseFut<DictionaryRemoveResult>

Removes a key from the dictionary, returning the Capability value.

• error DictionaryError.NOT_FOUND if the dictionary does not contain the key.

pub fn read(&self) -> QueryResponseFut<Vec<DictionaryItem>>

Returns all items in this dictionary, sorted by key in natural order.

This operation creates shallow clones of values.

pub fn clone(&self) -> QueryResponseFut<ClientEnd<DictionaryMarker>>

Creates a new connection to the same underlying dictionary.

Use Copy to a new dictionary with clones of all the exiting entries.

pub fn copy(&self) -> QueryResponseFut<ClientEnd<DictionaryMarker>>

Create a new dictionary that contains a clone of all the entries in this dictionary.

For example, if this dictionary contains nested dictionaries, the newly created dictionary will contain references to those same nested dictionaries because the entries are cloned rather than copied.

pub fn enumerate( &self, contents: ServerEnd<DictionaryIteratorMarker> ) -> Result<(), Error>

Enumerates the entries in this dictionary.

Creates a clone of each item during enumeration.

pub fn drain( &self, contents: Option<ServerEnd<DictionaryIteratorMarker>> ) -> Result<(), Error>

Removes all the entries in this dictionary.

If contents is not provided, all the items are discarded without enumerating them.

Trait Implementations

impl Clone for DictionaryProxy

fn clone(&self) -> DictionaryProxy

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DictionaryProxy

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

Formats the value using the given formatter.

impl DictionaryProxyInterface for DictionaryProxy

type InsertResponseFut = QueryResponseFut<Result<(), DictionaryError>>

fn insert(&self, key: &str, value: Capability) -> Self::InsertResponseFut

type GetResponseFut = QueryResponseFut<Result<Capability, DictionaryError>>

fn get(&self, key: &str) -> Self::GetResponseFut

type RemoveResponseFut = QueryResponseFut<Result<Capability, DictionaryError>>

fn remove(&self, key: &str) -> Self::RemoveResponseFut

type ReadResponseFut = QueryResponseFut<Vec<DictionaryItem>>

fn read(&self) -> Self::ReadResponseFut

type CloneResponseFut = QueryResponseFut<ClientEnd<DictionaryMarker>>

fn clone(&self) -> Self::CloneResponseFut

type CopyResponseFut = QueryResponseFut<ClientEnd<DictionaryMarker>>

fn copy(&self) -> Self::CopyResponseFut

fn enumerate( &self, contents: ServerEnd<DictionaryIteratorMarker> ) -> Result<(), Error>

fn drain( &self, contents: Option<ServerEnd<DictionaryIteratorMarker>> ) -> Result<(), Error>

impl Proxy for DictionaryProxy

type Protocol = DictionaryMarker

The protocol which this Proxy controls.

fn from_channel(inner: AsyncChannel) -> Self

Create a proxy over the given channel.

fn into_channel(self) -> Result<AsyncChannel, Self>

Attempt to convert the proxy back into a channel.

fn as_channel(&self) -> &AsyncChannel

Get a reference to the proxy’s underlying channel.

fn into_client_end(self) -> Result<ClientEnd<Self::Protocol>, Self>

Attempt to convert the proxy back into a client end.

fn is_closed(&self) -> bool

Returns true if the proxy has received the PEER_CLOSED signal.

fn on_closed(&self) -> OnSignals<'_, Unowned<'_, Handle>>

Returns a future that completes when the proxy receives the PEER_CLOSED signal.