Struct ffi_support::handle_map::HandleMap

pub struct HandleMap<T> {
    id: u16,
    first_free: u16,
    num_entries: usize,
    entries: Vec<Entry<T>>,
}

HandleMap is a collection type which can hold any type of value, and offers a stable handle which can be used to retrieve it on insertion. These handles offer methods for converting to and from 64 bit integers, meaning they're very easy to pass over the FFI (they also implement [IntoFfi] for the same purpose).

See the module level docs for more information.

Note: In FFI code, most usage of HandleMap will be done through the [ConcurrentHandleMap] type, which is a thin wrapper around a RwLock<HandleMap<Mutex<T>>>.

Fields

id: u16

first_free: u16

num_entries: usize

entries: Vec<Entry<T>>

Implementations

impl<T> HandleMap<T>

pub fn new() -> Self

Create a new HandleMap with the default capacity.

pub fn new_with_capacity(request: usize) -> Self

Allocate a new HandleMap. Note that the actual capacity may be larger than the requested value.

Panics if request is greater than handle_map::MAX_CAPACITY

pub fn len(&self) -> usize

Get the number of entries in the HandleMap.

pub fn is_empty(&self) -> bool

Returns true if the HandleMap is empty.

pub fn capacity(&self) -> usize

Returns the number of slots allocated in the handle map.

fn ensure_capacity(&mut self, cap_at_least: usize)

fn debug_check_valid(&self)

fn assert_valid(&self)

pub fn insert(&mut self, v: T) -> Handle

Insert an item into the map, and return a handle to it.

fn check_handle(&self, h: Handle) -> Result<usize, HandleError>

pub fn delete(&mut self, h: Handle) -> Result<(), HandleError>

Delete an item from the HandleMap.

pub fn remove(&mut self, h: Handle) -> Result<T, HandleError>

Remove an item from the HandleMap, returning the old value.

pub fn get(&self, h: Handle) -> Result<&T, HandleError>

Get a reference to the item referenced by the handle, or return a [HandleError] describing the problem.

pub fn get_mut(&mut self, h: Handle) -> Result<&mut T, HandleError>

Get a mut reference to the item referenced by the handle, or return a [HandleError] describing the problem.

Trait Implementations

impl<T: Clone> Clone for HandleMap<T>

fn clone(&self) -> HandleMap<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for HandleMap<T>

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

Formats the value using the given formatter.

impl<T> Default for HandleMap<T>

fn default() -> Self

Returns the "default value" for a type.

impl<T> Index<Handle> for HandleMap<T>

type Output = T

The returned type after indexing.

fn index(&self, h: Handle) -> &T

Performs the indexing (container[index]) operation.