Struct TypeMap

pub struct TypeMap<S: ?Sized = DefaultStorage>(/* private fields */);

TypeMap is a simple abstraction around the standard library’s HashMap type, where types are its keys. This allows for statically-checked value retrieval.

Implementations

impl TypeMap

pub fn new() -> Self

Creates a new instance of TypeMap.

impl<S: ?Sized + Any + Send + Sync> TypeMap<S>

pub fn custom() -> Self

Creates a new instance of TypeMap with a custom storage type.

pub fn len(&self) -> usize

Returns the amount of entries in the map.

pub fn is_empty(&self) -> bool

Returns an indicator whether the map is empty (no entries).

pub fn clear(&mut self)

Clears all entries in the map.

pub fn contains_key<T>(&self) -> bool

where T: TypeMapKey,

Returns true if the map contains a value for the specified TypeMapKey.

use typemap_rev::{TypeMap, TypeMapKey};

struct Number;

impl TypeMapKey for Number {
    type Value = i32;
}

let mut map = TypeMap::new();
assert!(!map.contains_key::<Number>());
map.insert::<Number>(42);
assert!(map.contains_key::<Number>());

pub fn insert<T>(&mut self, value: T::Value)

where T: TypeMapKey, T::Value: IntoBox<S>,

Inserts a new value based on its TypeMapKey. If the value has been already inserted, it will be overwritten with the new value.

use typemap_rev::{TypeMap, TypeMapKey};

struct Number;

impl TypeMapKey for Number {
    type Value = i32;
}

let mut map = TypeMap::new();
map.insert::<Number>(42);
// Overwrite the value of `Number` with -42.
map.insert::<Number>(-42);

pub fn entry<T>(&mut self) -> Entry<'_, T, S>

where T: TypeMapKey, T::Value: IntoBox<S>,

Retrieve the entry based on its TypeMapKey

pub fn get<T>(&self) -> Option<&T::Value>

where T: TypeMapKey, T::Value: IntoBox<S>,

Retrieve a reference to a value based on its TypeMapKey. Returns None if it couldn’t be found.

use typemap_rev::{TypeMap, TypeMapKey};

struct Number;

impl TypeMapKey for Number {
    type Value = i32;
}

let mut map = TypeMap::new();
map.insert::<Number>(42);

assert_eq!(*map.get::<Number>().unwrap(), 42);

pub fn get_mut<T>(&mut self) -> Option<&mut T::Value>

where T: TypeMapKey, T::Value: IntoBox<S>,

Retrieve a mutable reference to a value based on its TypeMapKey. Returns None if it couldn’t be found.

use typemap_rev::{TypeMap, TypeMapKey};

struct Number;

impl TypeMapKey for Number {
    type Value = i32;
}

let mut map = TypeMap::new();
map.insert::<Number>(42);

assert_eq!(*map.get::<Number>().unwrap(), 42);
*map.get_mut::<Number>().unwrap() -= 42;
assert_eq!(*map.get::<Number>().unwrap(), 0);

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

where T: TypeMapKey, T::Value: IntoBox<S>,

Removes a value from the map based on its TypeMapKey.

Returns a boolean indicating whether the value existed prior to its removal.

use typemap_rev::{TypeMap, TypeMapKey};

struct Text;

impl TypeMapKey for Text {
    type Value = String;
}

let mut map = TypeMap::new();
map.insert::<Text>(String::from("Hello TypeMap!"));
assert!(map.remove::<Text>().is_some());
assert!(map.get::<Text>().is_none());

Trait Implementations

impl<S: ?Sized> Clone for TypeMap<S>

where Box<S>: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: ?Sized + DebuggableStorage> Debug for TypeMap<S>

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

Formats the value using the given formatter.

impl<S: ?Sized> Default for TypeMap<S>

fn default() -> Self

Returns the “default value” for a type.

impl<S: ?Sized> Extend<(TypeId, Box<S>)> for TypeMap<S>

fn extend<T: IntoIterator<Item = (TypeId, Box<S>)>>(&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<S: ?Sized> FromIterator<(TypeId, Box<S>)> for TypeMap<S>

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

Creates a value from an iterator.

impl<S: ?Sized> IntoIterator for TypeMap<S>

type Item = (TypeId, Box<S>)

The type of the elements being iterated over.

type IntoIter = IntoIter<TypeId, Box<S>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.