Struct HashDynMap 

pub struct HashDynMap<K, DynT, S = RandomState>
where
    DynT: ?Sized,
{ /* private fields */ }

Implementations

impl<K, DynT> HashDynMap<K, DynT>

where DynT: ?Sized,

pub fn new() -> Self

impl<K, DynT: ?Sized, S> HashDynMap<K, DynT, S>

pub fn with_hasher(hash_state: S) -> Self

impl<K, DynT> HashDynMap<K, DynT>

where DynT: ?Sized, K: Hash + Eq + Clone,

pub fn insert<T>(&mut self, key: K, value: T) -> Result<DynKey<K, T>, T>

where DynT: MakeConcrete<T>,

Tries to insert a new value with provided key. If value with this key exists, returns Err with value, otherwise Ok containing the key.

pub unsafe fn insert_overwrite<T>(&mut self, key: K, value: T) -> DynKey<K, T>

where DynT: MakeConcrete<T>,

Inserts the value with provided key, potentially overwriting previous value which can make earlier keys hold the wrong type. This method can be more performant than standard insert.

SAFETY: You must ensure that you won’t acces this value with old key with incorrect binded type

pub fn get<T>(&self, key: &DynKey<K, T>) -> Option<&T>

where DynT: MakeConcrete<T>,

Returns a reference to the value corresponding to the key and type bind

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

where DynT: MakeConcrete<T>,

Returns a mutable reference to the value corresponding to the key and type bind

pub fn get_dyn(&self, key: &K) -> Option<&DynT>

Returns a reference to the value corresponding to the key without concrete type

pub fn get_dyn_mut(&mut self, key: &K) -> Option<&mut DynT>

Returns a mutable reference to the value corresponding to the key without concrete type

pub fn iter(&self) -> impl Iterator<Item = (&K, &Box<DynT>)>

Returns an iterator over references of entries of the map

pub fn iter_mut(&mut self) -> impl Iterator<Item = (&K, &mut Box<DynT>)>

Returns an iterator over mutable references of entries of the map

pub fn is_empty(&self) -> bool

Returns whether the map is empty (i.e. contains no elements)

pub fn len(&self) -> usize

Returns the number of elements in the map

pub fn remove<T>(&mut self, key: &DynKey<K, T>) -> Option<Box<T>>

where DynT: MakeConcrete<T>,

Removes the element with the given key from the map, returning its concrete type value if found

pub fn remove_dyn(&mut self, key: &K) -> Option<Box<DynT>>

Removes the element with the given key from the map, returning corresponding trait object

pub fn clear(&mut self)

Removes all elements from the map

pub fn contains_key(&self, key: &K) -> bool

Returns whether the map contains an element with the given key

Trait Implementations

impl<K: Clone, DynT, S: Clone> Clone for HashDynMap<K, DynT, S>

where DynT: ?Sized + Clone,

fn clone(&self) -> HashDynMap<K, DynT, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug, DynT, S: Debug> Debug for HashDynMap<K, DynT, S>

where DynT: ?Sized + Debug,

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

Formats the value using the given formatter.

impl<K: Default, DynT, S: Default> Default for HashDynMap<K, DynT, S>

where DynT: ?Sized + Default,

fn default() -> HashDynMap<K, DynT, S>

Returns the “default value” for a type.

impl<K, DynT: ?Sized> IntoIterator for HashDynMap<K, DynT>

type Item = (K, Box<DynT>)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, Box<DynT>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.