Struct vial::TypeCache

pub struct TypeCache { /* fields omitted */ }

The TypeCache is heavily inspired by the state crate and the way the Rocket framework handles global and local state. You could say we've immutably borrowed some ideas. Rim-shot!

Basically, we've got a hash that can store different types but only one of each type. The type id is the key, and you need to know what type you're asking for when you call get() to be able to do anything with it:

let cache = TypeCache::new();

cache.set::<String>("Hi friends".to_string());
assert_eq!(Some(&"Hi friends".to_string()), cache.get::<String>());

cache.set::<usize>(12345);
assert_eq!(Some(&12345), cache.get::<usize>());

We use this in Vial for global state as well as local request state, however this design is flawed as the local cache shouldn't be forced into Send + Sync. These two will be separated in a future release.

Implementations

impl TypeCache

pub fn new() -> TypeCache

Create a new, empty TypeCache.

pub fn get<T: Send + Sync + 'static>(&self) -> Option<&T>

TypeCache works like a regular hash map, but with types as keys. Meaning it can only store one of each type. Choose wisely.

pub fn set<T: Send + Sync + 'static>(&self, v: T)

As long as your object is Send + Sync + 'static, TypeCache can store it.

Trait Implementations

impl Debug for TypeCache

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

Formats the value using the given formatter.

impl Default for TypeCache

pub fn default() -> TypeCache

Returns the "default value" for a type.