Struct DeviceHandle 

pub struct DeviceHandle<S>
where
    S: DeviceService,
{ /* private fields */ }

TODO: Docs

Implementations

impl<S> DeviceHandle<S>

where S: DeviceService,

pub const fn is_blocking() -> bool

pub fn insert( device_id: DeviceId, service: S, ) -> Result<DeviceHandle<S>, ServiceCreationError>

pub fn new(device_id: DeviceId) -> DeviceHandle<S>

pub fn device_id(&self) -> DeviceId

pub fn utilities(&self) -> Arc<dyn Any + Sync + Send>

pub fn submit_blocking<'a, R, T>(&self, task: T) -> Result<R, CallError>

where R: Send, T: FnOnce(&mut S) -> R + Send + 'a,

pub fn submit<T>(&self, task: T)

where T: FnOnce(&mut S) + Send + 'static,

pub fn flush_queue(&self)

pub fn exclusive<R, T>(&self, task: T) -> Result<R, CallError>

where R: Send, T: FnOnce() -> R + Send,

pub fn shutdown(device_id: DeviceId)

Stops the background runner threads for device_id, blocking until they exit. Queued tasks run before the threads stop. Live handles keep their runner alive, so all handles for the device should be dropped first.

Only meaningful for handle implementations with background threads; a no-op otherwise.

Scope

This is device-wide, and S is ignored. It shuts down every DeviceService registered on device_id, across both service stages, not only S. The type parameter selects the handle implementation to dispatch through, nothing more.

DeviceId is not unique across runtimes either: type_id is assigned per runtime, so distinct backends can hand out the same id. Shutting down a device from one runtime can therefore tear down another runtime’s services on the colliding id, and block while that runtime’s handles are still live.

Trait Implementations

impl<S> Clone for DeviceHandle<S>

where S: DeviceService,

fn clone(&self) -> DeviceHandle<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.