Struct HandleMap

pub struct HandleMap<T, U>
where
    T: Handled + ?Sized,
{ /* private fields */ }

An efficient implementation of a mapping between handles and arbitrary data.

This collection implements the classic “map” data-structure functionality, in the special case in which the keys are actually instances of Handle. This restriction enables this more efficient implementation of a map.

Type Arguments

• T: The Handled type whose handles are used to index into the map.
• U: The type of the target values being mapped.

Example

struct LinkedListNode { next: Option<Handle<LinkedListNode>> }
impl Handled for LinkedListNode { type HandleCoreType = u8; }

let mut nodes = HandledVec::new();
let tail_handle = nodes.insert(LinkedListNode { next: None });
let head_handle = nodes.insert(LinkedListNode { next: Some(tail_handle) });

let mut metadata = HandleMap::new();
metadata.insert(head_handle, "Head Node");
metadata.insert(tail_handle, "Tail Node");

assert_eq!(metadata.get(tail_handle), Some("Tail Node").as_ref());

Implementations

impl<T, U> HandleMap<T, U>

where T: Handled + ?Sized,

pub fn new() -> Self

Create a new, empty, map.

pub fn insert(&mut self, key: Handle<T>, item: U) -> bool

Insert a key-value pair to the map.

pub fn get(&self, key: Handle<T>) -> Option<&U>

Get a reference to the value mapped to a given key, or None if the key is not present.

pub fn get_mut(&mut self, key: Handle<T>) -> Option<&mut U>

Get a mutable reference to the value mapped to a given key, or None if the key was never inserted.

pub fn contains_key(&self, key: Handle<T>) -> bool

Check whether a given key is present in the map.

pub fn iter(&self) -> impl Iterator<Item = (Handle<T>, &U)>

Get an iterator of references to the values held in the maps, and their corresponding keys.

pub fn keys<'a>(&'a self) -> impl Iterator<Item = Handle<T>> + 'a

Get an iterator over the available keys in the map.

Trait Implementations

impl<T, U> Clone for HandleMap<T, U>

where T: Handled + ?Sized, U: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, U> Debug for HandleMap<T, U>

where T: Handled, U: Debug,

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

Formats the value using the given formatter.

impl<T, U> From<Vec<Option<U>>> for HandleMap<T, U>

where T: Handled + ?Sized,

fn from(contents: Vec<Option<U>>) -> Self

Converts to this type from the input type.

impl<'a, T, U> IntoIterator for &'a HandleMap<T, U>

where T: Handled + ?Sized,

type Item = (Handle<T>, &'a U)

The type of the elements being iterated over.

type IntoIter = Iter<'a, T, U>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, U> PartialEq for HandleMap<T, U>

where T: Handled + ?Sized, U: PartialEq,

fn eq(&self, __other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, U> Eq for HandleMap<T, U>

where T: Handled + ?Sized, U: Eq,