1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
use hashbrown::HashMap;
use std::{
any::{Any, TypeId},
fmt,
hash::{BuildHasherDefault, Hasher},
};
#[derive(Default)]
pub struct StateSet(HashMap<TypeId, Box<dyn Any + Send + Sync>, BuildHasherDefault<IdHasher>>);
impl StateSet {
pub fn new() -> Self {
Self::default()
}
pub fn insert<T: Send + Sync + 'static>(&mut self, val: T) -> Option<T> {
self.0
.insert(TypeId::of::<T>(), Box::new(val))
.and_then(|boxed| (boxed as Box<dyn Any>).downcast().ok().map(|boxed| *boxed))
}
pub fn contains<T: 'static>(&self) -> bool {
self.0.get(&TypeId::of::<T>()).is_some()
}
pub fn get<T: 'static>(&self) -> Option<&T> {
self.0
.get(&TypeId::of::<T>())
.and_then(|boxed| (&**boxed as &(dyn Any)).downcast_ref())
}
pub fn get_mut<T: 'static>(&mut self) -> Option<&mut T> {
self.0
.get_mut(&TypeId::of::<T>())
.and_then(|boxed| (&mut **boxed as &mut (dyn Any)).downcast_mut())
}
pub fn take<T: 'static>(&mut self) -> Option<T> {
self.0
.remove(&TypeId::of::<T>())
.and_then(|boxed| (boxed as Box<dyn Any>).downcast().ok().map(|boxed| *boxed))
}
pub fn get_or_insert<T: Send + Sync + 'static>(&mut self, default: T) -> &mut T {
self.0
.entry(TypeId::of::<T>())
.or_insert_with(|| Box::new(default))
.downcast_mut()
.expect("StateSet maintains the invariant the value associated with a given TypeId is always the type associated with that TypeId.")
}
pub fn get_or_insert_with<F, T>(&mut self, default: F) -> &mut T
where
F: FnOnce() -> T,
T: Send + Sync + 'static,
{
self.0
.entry(TypeId::of::<T>())
.or_insert_with(|| Box::new(default()))
.downcast_mut()
.expect("StateSet maintains the invariant the value associated with a given TypeId is always the type associated with that TypeId.")
}
}
impl fmt::Debug for StateSet {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("StateSet").finish()
}
}
#[derive(Default)]
struct IdHasher(u64);
impl Hasher for IdHasher {
fn write(&mut self, _: &[u8]) {
unreachable!("TypeId calls write_u64");
}
#[inline]
fn write_u64(&mut self, id: u64) {
self.0 = id;
}
#[inline]
fn finish(&self) -> u64 {
self.0
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_extensions() {
#[derive(Debug, PartialEq)]
struct MyType(i32);
let mut map = StateSet::new();
map.insert(5i32);
map.insert(MyType(10));
assert_eq!(map.get(), Some(&5i32));
assert_eq!(map.get_mut(), Some(&mut 5i32));
assert_eq!(map.take::<i32>(), Some(5i32));
assert!(map.get::<i32>().is_none());
assert_eq!(map.get::<bool>(), None);
assert_eq!(map.get(), Some(&MyType(10)));
}
}