Struct HandledVec 

pub struct HandledVec<T>
where
    T: Handled,
{ /* private fields */ }

A collection of Handled instances with automatically-generated handles, supporting efficient handle-to-instance lookup.

This data structure accumulates instances of some Handled type T, while automatically generating handles to each of the contained instances, based on their order of insertion to the vector. It supports efficient handle-to-instance lookup.

This usually serves for generating handles to instances of complex data types.

Example

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

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

Implementations

impl<T> HandledVec<T>

where T: Handled,

pub fn new() -> Self

Creates a new, empty, HandledVec.

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

Adds a new item into the collection, and returns its newly generated handle.

pub fn list_handles(&self) -> impl Iterator<Item = Handle<T>>

Lists the handles to all available items in the collection.

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

Get an iterator of references to the items in the collection.

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T>

Get an iterator of mutable references to the items in the collection.

Trait Implementations

impl<T> Clone for HandledVec<T>

where T: Handled + Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for HandledVec<T>

where T: Handled + Debug,

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

Formats the value using the given formatter.

impl<'a, T> FromIterator<T> for HandledVec<T>

where T: Handled,

fn from_iter<U: IntoIterator<Item = T>>(iter: U) -> Self

Creates a value from an iterator.

impl<T> Index<Handle<T>> for HandledVec<T>

where T: Handled,

fn index(&self, index: Handle<T>) -> &Self::Output

Get a reference to the collection’s item that’s associated with the given handle.

type Output = T

The returned type after indexing.

impl<T> IndexMut<Handle<T>> for HandledVec<T>

where T: Handled,

fn index_mut(&mut self, index: Handle<T>) -> &mut Self::Output

Get a mutable reference to the collection’s item that’s associated with the given handle.

impl<'a, T> IntoIterator for &'a HandledVec<T>

where T: Handled,

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut HandledVec<T>

where T: Handled,

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> PartialEq for HandledVec<T>

where T: Handled + PartialEq,

fn eq(&self, other: &HandledVec<T>) -> 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> Eq for HandledVec<T>

where T: Handled + Eq,

impl<T> StructuralPartialEq for HandledVec<T>

where T: Handled,