Struct ResourceTable 

pub struct ResourceTable { /* private fields */ }

The ResourceTable type maps a Resource<T> to its T.

Implementations

impl ResourceTable

pub fn new() -> ResourceTable

Create an empty table

pub fn is_empty(&self) -> bool

Returns whether or not this table is empty.

Note that this is an O(n) operation, where n is the number of entries in the backing Vec.

pub fn with_capacity(capacity: usize) -> ResourceTable

Create an empty table with at least the specified capacity.

pub fn push<T>(&mut self, entry: T) -> Result<Resource<T>, ResourceTableError>

where T: Send + 'static,

Inserts a new value T into this table, returning a corresponding Resource<T> which can be used to refer to it after it was inserted.

pub fn push_child<T, U>( &mut self, entry: T, parent: &Resource<U>, ) -> Result<Resource<T>, ResourceTableError>

where T: Send + 'static, U: 'static,

Insert a resource at the next available index, and track that it has a parent resource.

The parent must exist to create a child. All children resources must be destroyed before a parent can be destroyed - otherwise ResourceTable::delete will fail with ResourceTableError::HasChildren.

Parent-child relationships are tracked inside the table to ensure that a parent resource is not deleted while it has live children. This allows child resources to hold “references” to a parent by table index, to avoid needing e.g. an Arc<Mutex<parent>> and the associated locking overhead and design issues, such as child existence extending lifetime of parent referent even after parent resource is destroyed, possibility for deadlocks.

pub fn add_child<T, U>( &mut self, child: Resource<T>, parent: Resource<U>, ) -> Result<(), ResourceTableError>

where T: 'static, U: 'static,

Add an already-resident child to a resource.

pub fn remove_child<T, U>( &mut self, child: Resource<T>, parent: Resource<U>, ) -> Result<(), ResourceTableError>

where T: 'static, U: 'static,

Remove a child to from a resource (but leave it in the table).

pub fn get<T>(&self, key: &Resource<T>) -> Result<&T, ResourceTableError>

where T: Any,

Get an immutable reference to a resource of a given type at a given index.

Multiple shared references can be borrowed at any given time.

pub fn get_mut<T>( &mut self, key: &Resource<T>, ) -> Result<&mut T, ResourceTableError>

where T: Any,

Get an mutable reference to a resource of a given type at a given index.

pub fn get_any_mut( &mut self, key: u32, ) -> Result<&mut (dyn Any + 'static), ResourceTableError>

Returns the raw Any at the key index provided.

pub fn delete<T>( &mut self, resource: Resource<T>, ) -> Result<T, ResourceTableError>

where T: Any,

Remove the specified entry from the table.

pub fn iter_entries<'a, T>( &'a mut self, map: BTreeMap<u32, T>, ) -> impl Iterator<Item = (Result<&'a mut (dyn Any + 'static), ResourceTableError>, T)>

Zip the values of the map with mutable references to table entries corresponding to each key. As the keys in the BTreeMap are unique, this iterator can give mutable references with the same lifetime as the mutable reference to the ResourceTable.

pub fn iter_children<T>( &self, parent: &Resource<T>, ) -> Result<impl Iterator<Item = &(dyn Any + Send + 'static)> + use<'_, T>, ResourceTableError>

where T: 'static,

Iterate over all children belonging to the provided parent

pub fn iter_mut( &mut self, ) -> impl Iterator<Item = &mut (dyn Any + Send + 'static)>

Iterate over all the entries in this table.

Trait Implementations

impl Debug for ResourceTable

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

Formats the value using the given formatter.

impl Default for ResourceTable

fn default() -> ResourceTable

Returns the “default value” for a type.

impl Host for ResourceTable

fn poll( &mut self, pollables: Vec<Resource<DynPollable>>, ) -> Result<Vec<u32>, Error>

Poll for completion on a set of pollables.

impl Host for ResourceTable

fn convert_stream_error( &mut self, err: StreamError, ) -> Result<StreamError, Error>

impl Host for ResourceTable

async fn poll( &mut self, pollables: Vec<Resource<DynPollable>>, ) -> Result<Vec<u32>, Error>

Poll for completion on a set of pollables.

impl Host for ResourceTable

fn convert_stream_error( &mut self, err: StreamError, ) -> Result<StreamError, Error>

impl HostError for ResourceTable

fn drop(&mut self, err: Resource<Error>) -> Result<(), Error>

fn to_debug_string(&mut self, err: Resource<Error>) -> Result<String, Error>

Returns a string that is suitable to assist humans in debugging this error.

impl HostInputStream for ResourceTable

fn drop(&mut self, stream: Resource<Box<dyn InputStream>>) -> Result<(), Error>

fn read( &mut self, stream: Resource<Box<dyn InputStream>>, len: u64, ) -> Result<Vec<u8>, StreamError>

Perform a non-blocking read from the stream.

fn blocking_read( &mut self, stream: Resource<Box<dyn InputStream>>, len: u64, ) -> Result<Vec<u8>, StreamError>

Read bytes from a stream, after blocking until at least one byte can be read. Except for blocking, behavior is identical to read.

fn skip( &mut self, stream: Resource<Box<dyn InputStream>>, len: u64, ) -> Result<u64, StreamError>

Skip bytes from a stream. Returns number of bytes skipped.

fn blocking_skip( &mut self, stream: Resource<Box<dyn InputStream>>, len: u64, ) -> Result<u64, StreamError>

Skip bytes from a stream, after blocking until at least one byte can be skipped. Except for blocking behavior, identical to skip.

fn subscribe( &mut self, stream: Resource<Box<dyn InputStream>>, ) -> Result<Resource<DynPollable>, Error>

Create a pollable which will resolve once either the specified stream has bytes available to read or the other end of the stream has been closed. The created pollable is a child resource of the input-stream. Implementations may trap if the input-stream is dropped before all derived pollables created with this function are dropped.

impl HostInputStream for ResourceTable

async fn drop( &mut self, stream: Resource<Box<dyn InputStream>>, ) -> Result<(), Error>

fn read( &mut self, stream: Resource<Box<dyn InputStream>>, len: u64, ) -> Result<Vec<u8>, StreamError>

Perform a non-blocking read from the stream.

async fn blocking_read( &mut self, stream: Resource<Box<dyn InputStream>>, len: u64, ) -> Result<Vec<u8>, StreamError>

Read bytes from a stream, after blocking until at least one byte can be read. Except for blocking, behavior is identical to read.

fn skip( &mut self, stream: Resource<Box<dyn InputStream>>, len: u64, ) -> Result<u64, StreamError>

Skip bytes from a stream. Returns number of bytes skipped.

async fn blocking_skip( &mut self, stream: Resource<Box<dyn InputStream>>, len: u64, ) -> Result<u64, StreamError>

Skip bytes from a stream, after blocking until at least one byte can be skipped. Except for blocking behavior, identical to skip.

fn subscribe( &mut self, stream: Resource<Box<dyn InputStream>>, ) -> Result<Resource<DynPollable>, Error>

Create a pollable which will resolve once either the specified stream has bytes available to read or the other end of the stream has been closed. The created pollable is a child resource of the input-stream. Implementations may trap if the input-stream is dropped before all derived pollables created with this function are dropped.

impl HostOutputStream for ResourceTable

fn drop(&mut self, stream: Resource<Box<dyn OutputStream>>) -> Result<(), Error>

fn check_write( &mut self, stream: Resource<Box<dyn OutputStream>>, ) -> Result<u64, StreamError>

Check readiness for writing. This function never blocks.

fn write( &mut self, stream: Resource<Box<dyn OutputStream>>, bytes: Vec<u8>, ) -> Result<(), StreamError>

Perform a write. This function never blocks.

fn blocking_write_and_flush( &mut self, stream: Resource<Box<dyn OutputStream>>, bytes: Vec<u8>, ) -> Result<(), StreamError>

Perform a write of up to 4096 bytes, and then flush the stream. Block until all of these operations are complete, or an error occurs.

fn blocking_write_zeroes_and_flush( &mut self, stream: Resource<Box<dyn OutputStream>>, len: u64, ) -> Result<(), StreamError>

Perform a write of up to 4096 zeroes, and then flush the stream. Block until all of these operations are complete, or an error occurs.

fn subscribe( &mut self, stream: Resource<Box<dyn OutputStream>>, ) -> Result<Resource<DynPollable>, Error>

Create a pollable which will resolve once the output-stream is ready for more writing, or an error has occurred. When this pollable is ready, check-write will return ok(n) with n>0, or an error.

fn write_zeroes( &mut self, stream: Resource<Box<dyn OutputStream>>, len: u64, ) -> Result<(), StreamError>

Write zeroes to a stream.

fn flush( &mut self, stream: Resource<Box<dyn OutputStream>>, ) -> Result<(), StreamError>

Request to flush buffered output. This function never blocks.

fn blocking_flush( &mut self, stream: Resource<Box<dyn OutputStream>>, ) -> Result<(), StreamError>

Request to flush buffered output, and block until flush completes and stream is ready for writing again.

fn splice( &mut self, dst: Resource<Box<dyn OutputStream>>, src: Resource<Box<dyn InputStream>>, len: u64, ) -> Result<u64, StreamError>

Read from one stream and write to another.

fn blocking_splice( &mut self, dst: Resource<Box<dyn OutputStream>>, src: Resource<Box<dyn InputStream>>, len: u64, ) -> Result<u64, StreamError>

Read from one stream and write to another, with blocking.

impl HostOutputStream for ResourceTable

async fn drop( &mut self, stream: Resource<Box<dyn OutputStream>>, ) -> Result<(), Error>

fn check_write( &mut self, stream: Resource<Box<dyn OutputStream>>, ) -> Result<u64, StreamError>

Check readiness for writing. This function never blocks.

fn write( &mut self, stream: Resource<Box<dyn OutputStream>>, bytes: Vec<u8>, ) -> Result<(), StreamError>

Perform a write. This function never blocks.

fn subscribe( &mut self, stream: Resource<Box<dyn OutputStream>>, ) -> Result<Resource<DynPollable>, Error>

Create a pollable which will resolve once the output-stream is ready for more writing, or an error has occurred. When this pollable is ready, check-write will return ok(n) with n>0, or an error.

async fn blocking_write_and_flush( &mut self, stream: Resource<Box<dyn OutputStream>>, bytes: Vec<u8>, ) -> Result<(), StreamError>

Perform a write of up to 4096 bytes, and then flush the stream. Block until all of these operations are complete, or an error occurs.

async fn blocking_write_zeroes_and_flush( &mut self, stream: Resource<Box<dyn OutputStream>>, len: u64, ) -> Result<(), StreamError>

Perform a write of up to 4096 zeroes, and then flush the stream. Block until all of these operations are complete, or an error occurs.

fn write_zeroes( &mut self, stream: Resource<Box<dyn OutputStream>>, len: u64, ) -> Result<(), StreamError>

Write zeroes to a stream.

fn flush( &mut self, stream: Resource<Box<dyn OutputStream>>, ) -> Result<(), StreamError>

Request to flush buffered output. This function never blocks.

async fn blocking_flush( &mut self, stream: Resource<Box<dyn OutputStream>>, ) -> Result<(), StreamError>

Request to flush buffered output, and block until flush completes and stream is ready for writing again.

fn splice( &mut self, dest: Resource<Box<dyn OutputStream>>, src: Resource<Box<dyn InputStream>>, len: u64, ) -> Result<u64, StreamError>

Read from one stream and write to another.

async fn blocking_splice( &mut self, dest: Resource<Box<dyn OutputStream>>, src: Resource<Box<dyn InputStream>>, len: u64, ) -> Result<u64, StreamError>

Read from one stream and write to another, with blocking.

impl HostPollable for ResourceTable

fn ready(&mut self, pollable: Resource<DynPollable>) -> Result<bool, Error>

Return the readiness of a pollable. This function never blocks.

fn block(&mut self, pollable: Resource<DynPollable>) -> Result<(), Error>

block returns immediately if the pollable is ready, and otherwise blocks until ready.

fn drop(&mut self, pollable: Resource<DynPollable>) -> Result<(), Error>

impl HostPollable for ResourceTable

async fn block(&mut self, pollable: Resource<DynPollable>) -> Result<(), Error>

block returns immediately if the pollable is ready, and otherwise blocks until ready.

async fn ready( &mut self, pollable: Resource<DynPollable>, ) -> Result<bool, Error>

Return the readiness of a pollable. This function never blocks.

fn drop(&mut self, pollable: Resource<DynPollable>) -> Result<(), Error>

impl Host for ResourceTable