Struct Registry 

pub struct Registry { /* private fields */ }

Collection of available and currently leased physical resource groups.

Registry queries only count currently available groups. A group remains in the registry while leased, but none of its capabilities can be acquired until its ResourceLease is returned.

Implementations

impl Registry

pub fn new() -> Self

Creates an empty registry with a unique identity.

The identity prevents a lease from accidentally being returned to a different registry.

pub fn register<T: 'static + Send>( &mut self, slot: ModuleSlot, module_id: ModuleID, resource: T, )

Registers a module resource as a single-capability physical group.

pub fn register_group<C: ResourceGroupCapabilities>( &mut self, slot: ModuleSlot, module_id: ModuleID, capabilities: C, ) -> Result<(), RegistryError>

Registers several logical capabilities backed by one physical module resource.

Errors

Returns RegistryError::DuplicateCapability if the tuple contains a concrete capability type more than once.

pub fn register_local_group<C: ResourceGroupCapabilities>( &mut self, slot: ModuleSlot, module_id: ModuleID, local_id: u16, capabilities: C, ) -> Result<(), RegistryError>

Registers a physical module group with a stable driver-defined local ID.

Local IDs only need to be unique within a module slot. They are useful when an app needs to correlate capabilities across boots.

Errors

Returns RegistryError::DuplicateCapability for duplicate capability types or RegistryError::DuplicateResourceId when local_id is already registered for slot.

pub fn register_groups<G: ResourceGroups>( &mut self, slot: ModuleSlot, module_id: ModuleID, groups: G, ) -> Result<(), RegistryError>

Atomically registers several physical groups from one module.

Errors

Returns RegistryError::DuplicateCapability if any group repeats a concrete capability type.

pub fn register_platform<T: 'static + Send>(&mut self, resource: T)

Registers a platform resource as a single-capability physical group.

pub fn register_platform_group<C: ResourceGroupCapabilities>( &mut self, capabilities: C, ) -> Result<(), RegistryError>

Registers several logical capabilities backed by one physical platform resource.

Errors

Returns RegistryError::DuplicateCapability if the tuple contains a concrete capability type more than once.

pub fn resource_count<T: 'static + Send>(&self) -> usize

Returns the number of currently available groups providing T.

pub fn has<T: 'static + Send>(&self) -> bool

Returns whether at least one currently available group provides T.

pub fn has_at_least<T: 'static + Send>(&self, count: usize) -> bool

Returns whether at least count currently available groups provide T.

pub fn has_resource_set<S: ResourceSet>(&self) -> bool

Returns whether all resource types in S can be leased from different available physical groups.

pub fn take_resource<T: 'static + Send>(&mut self) -> Option<ResourceLease<T>>

Leases one available physical group through capability T.

pub fn take_resources<T: 'static + Send>( &mut self, count: usize, ) -> Option<Vec<ResourceLease<T>>>

Atomically leases count different groups through capability T.

A count of zero succeeds with an empty vector.

pub fn take_resource_set<S: ResourceSet>(&mut self) -> Option<S::Leases>

Atomically leases one resource of every type in S from different physical groups.

pub fn return_resource<T: 'static + Send>(&mut self, lease: ResourceLease<T>)

Returns a lease and makes its complete physical group available again.

Panics

Panics if the lease came from a different registry or if internal lease invariants have been violated.

Trait Implementations

impl Default for Registry

fn default() -> Self

Returns the “default value” for a type.