Struct dfb::Dfb

pub struct Dfb(_);

An “anymap” which uses TypeIDs as keys and VecDeques of that type as values.

Implementations

impl Dfb

pub fn new() -> Self

Creates a Dfb backed by HashMap::new

pub fn with_capacity(capacity: usize) -> Self

Creates a Dfb backed by HashMap::with_capacity

pub fn capacity(&self) -> usize

Wrapper for HashMap::capacity

pub fn keys(&self) -> Keys<'_, TypeId, VecDeque<Box<dyn Any>>>

Wrapper for HashMap::keys

pub fn values(&self) -> Values<'_, TypeId, VecDeque<Box<dyn Any>>>

Wrapper for HashMap::values

pub fn values_mut(&mut self) -> ValuesMut<'_, TypeId, VecDeque<Box<dyn Any>>>

Wrapper for HashMap::values_mut

pub fn iter(&self) -> Iter<'_, TypeId, VecDeque<Box<dyn Any>>>

Wrapper for HashMap::iter

pub fn iter_mut(&mut self) -> IterMut<'_, TypeId, VecDeque<Box<dyn Any>>>

Wrapper for HashMap::iter_mut

pub fn len(&self) -> usize

Wrapper for HashMap::len

pub fn is_empty(&self) -> bool

Wrapper for HashMap::is_empty

pub fn drain(&mut self) -> Drain<'_, TypeId, VecDeque<Box<dyn Any>>>

Wrapper for HashMap::drain

pub fn clear(&mut self)

Wrapper for HashMap::clear

pub fn reserve(&mut self, additional: usize)

Wrapper for HashMap::reserve

pub fn shrink_to_fit(&mut self)

Wrapper for HashMap::shrink_to_fit

pub fn entry<T: 'static>(&mut self) -> Entry<'_, TypeId, VecDeque<Box<dyn Any>>>

Generic wrapper for HashMap::entry

pub fn contains<T: Any>(&self) -> bool

Generic wrapper for HashMap::get_key_value

pub fn insert(&mut self, value: impl Any)

Generic wrapper for HashMap::insert. If one or more values of this type already exist in the map, this will push a new value into the FIFO that contains them. If no value exists, this will create a new FIFO containing the inserted element.

pub fn insert_dyn(&mut self, value: Box<dyn Any>)

Like Dfb::insert, but allows boxed values of unknown type.

pub fn remove<T: Any>(&mut self) -> Option<T>

Generic wrapper for HashMap::remove. Returns and removes the earliest inserted element of this type if it exists. If the element returned was the last remaining element of its type, the internal FIFO for this type is deleted.

pub fn retain<F: FnMut(&TypeId, &mut VecDeque<Box<dyn Any>>) -> bool>(
    &mut self,
    f: F
)

Wrapper for HashMap::retain

Trait Implementations

impl Debug for Dfb

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

Formats the value using the given formatter.

impl Default for Dfb

fn default() -> Self

Returns the “default value” for a type.

impl Extend<(TypeId, VecDeque<Box<dyn Any + 'static, Global>>)> for Dfb

fn extend<T: IntoIterator<Item = (TypeId, VecDeque<Box<dyn Any>>)>>(
    &mut self,
    iter: T
)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<const N: usize> From<[Box<dyn Any + 'static, Global>; N]> for Dfb

fn from(items: [Box<dyn Any>; N]) -> Self

Performs the conversion.

impl FromIterator<(TypeId, VecDeque<Box<dyn Any + 'static, Global>>)> for Dfb

fn from_iter<T: IntoIterator<Item = (TypeId, VecDeque<Box<dyn Any>>)>>(
    iter: T
) -> Self

Creates a value from an iterator.

impl FromIterator<Box<dyn Any + 'static, Global>> for Dfb

fn from_iter<T: IntoIterator<Item = Box<dyn Any>>>(iter: T) -> Self

Creates a value from an iterator.

impl Index<TypeId> for Dfb

type Output = VecDeque<Box<dyn Any>>

The returned type after indexing.

fn index(&self, key: TypeId) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IntoIterator for Dfb

type Item = (TypeId, VecDeque<Box<dyn Any>>)

The type of the elements being iterated over.

type IntoIter = IntoIter<TypeId, VecDeque<Box<dyn Any>>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a Dfb

type Item = (&'a TypeId, &'a VecDeque<Box<dyn Any>>)

The type of the elements being iterated over.

type IntoIter = Iter<'a, TypeId, VecDeque<Box<dyn Any>>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a mut Dfb

type Item = (&'a TypeId, &'a mut VecDeque<Box<dyn Any>>)

The type of the elements being iterated over.

type IntoIter = IterMut<'a, TypeId, VecDeque<Box<dyn Any>>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Send for Dfb

impl Sync for Dfb