Struct OrdDynMap 

pub struct OrdDynMap<K, DynT>
where
    DynT: ?Sized,
{ /* private fields */ }

Implementations

impl<K, DynT> OrdDynMap<K, DynT>

where DynT: ?Sized,

pub const fn new() -> Self

impl<K, DynT> OrdDynMap<K, DynT>

where DynT: ?Sized, K: Ord + 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> Clone for OrdDynMap<K, DynT>

where DynT: ?Sized + Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug, DynT> Debug for OrdDynMap<K, DynT>

where DynT: ?Sized + Debug,

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

Formats the value using the given formatter.

impl<K: Default, DynT> Default for OrdDynMap<K, DynT>

where DynT: ?Sized + Default,

fn default() -> OrdDynMap<K, DynT>

Returns the “default value” for a type.

impl<K: Eq, DynT> Eq for OrdDynMap<K, DynT>

where DynT: ?Sized + Eq,

impl<K: Hash, DynT> Hash for OrdDynMap<K, DynT>

where DynT: ?Sized + Hash,

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<K, DynT: ?Sized> IntoIterator for OrdDynMap<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.

impl<K: Ord, DynT> Ord for OrdDynMap<K, DynT>

where DynT: ?Sized + Ord,

fn cmp(&self, other: &OrdDynMap<K, DynT>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<K: PartialEq, DynT> PartialEq for OrdDynMap<K, DynT>

where DynT: ?Sized + PartialEq,

fn eq(&self, other: &OrdDynMap<K, DynT>) -> 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<K: PartialOrd, DynT> PartialOrd for OrdDynMap<K, DynT>

where DynT: ?Sized + PartialOrd,

fn partial_cmp(&self, other: &OrdDynMap<K, DynT>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<K, DynT> StructuralPartialEq for OrdDynMap<K, DynT>

where DynT: ?Sized,