Struct Dictionary 

pub struct Dictionary { /* private fields */ }

A capability that represents a dictionary of capabilities.

Implementations

impl Dictionary

pub fn new() -> Arc<Self>

Creates an empty dictionary.

pub fn new_with_not_found( not_found: impl Fn(&str) + 'static + Send + Sync, ) -> Arc<Self>

Creates an empty dictionary. When an external request tries to access a non-existent entry, the name of the entry will be sent using not_found.

pub fn register_update_notifier(&self, notifier_fn: UpdateNotifierFn)

Registers a new update notifier function with this dictionary. The function will be called whenever an entry is added to or removed from this dictionary. The function will be immediately called with an EntryUpdate::Add value for any entries already in this dictionary.

Note that this function will be called while the internal dictionary structure is locked, so it must not interact with the dictionary on which it is registered. It shouldn’t even hold a strong reference to the dictionary it’s registered on, as that’ll create a cycle and make LSAN sad.

pub fn insert(&self, key: Key, capability: Capability) -> Option<Capability>

Inserts an entry, mapping key to capability. If an entry already exists at key, the old value will be returned.

pub fn append(&self, other: &Dictionary) -> Result<(), ()>

pub fn get<Q>(&self, key: &Q) -> Option<Capability>

where Key: Borrow<Q> + Ord, Q: Ord + ?Sized,

Returns a clone of the capability associated with key. If there is no entry for key, None is returned.

pub fn get_or_insert( &self, key: &Key, default: impl FnOnce() -> Capability, ) -> Capability

Returns a clone of the capability associated with key, or populates it with default if it is not present.

pub fn remove(&self, key: &BorrowedName) -> Option<Capability>

Removes key from the entries, returning the capability at key if the key was already in the entries.

pub fn enumerate(&self) -> impl Iterator<Item = (Key, Capability)> + use<>

Returns an iterator over a clone of the entries, sorted by key.

pub fn snapshot_keys_as_strings(&self) -> Vec<String>

Returns the keys.

pub fn is_empty(&self) -> bool

Returns if entries is empty.

pub fn drain(&self) -> impl Iterator<Item = (Key, Capability)> + use<>

Removes all entries from the Dictionary and returns them as an iterator.

pub fn shallow_copy(&self) -> Arc<Self>

Creates a new Dictionary with entries cloned from this Dictionary.

This is a shallow copy. Values are cloned, not copied, so are new references to the same underlying data.

impl Dictionary

pub fn from_channel(dict: Channel) -> Result<Arc<Self>, RemoteError>

pub fn try_from_fsandbox( dictionary: DictionaryRef, ) -> Result<Arc<Self>, RemoteError>

pub fn to_fsandbox(self: Arc<Self>) -> DictionaryRef

pub fn try_into_directory_entry_oneshot( self: Arc<Self>, scope: ExecutionScope, token: Arc<WeakInstanceToken>, ) -> Result<Arc<dyn DirectoryEntry>, ConversionError>

Like [CapabilityBound::try_into_directory_entry], but this version actually consumes the contents of the Dictionary. In other words, if this function returns Ok, self will be empty. If any items are added to self later, they will not appear in the directory. This method is useful when the caller has no need to keep the original Dictionary. Note that even if there is only one reference to the Dictionary, calling [CapabilityBound::try_into_directory_entry] does not have the same effect because the vfs keeps alive reference to the Dictionary – see the comment in the implementation.

This is transitive: any Dictionarys nested in this one will be consumed as well.

Trait Implementations

impl CapabilityBound for Dictionary

fn debug_typename() -> &'static str

fn try_into_directory_entry( self: Arc<Self>, scope: ExecutionScope, token: Arc<WeakInstanceToken>, ) -> Result<Arc<dyn DirectoryEntry>, ConversionError>

Converts this capability into a directory entry.

impl Debug for Dictionary

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

Formats the value using the given formatter.

impl Default for Dictionary

fn default() -> Self

Returns the “default value” for a type.