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
|
//! This module defines a `DynMap` -- a container for heterogeneous maps.
//!
//! This means that `DynMap` stores a bunch of hash maps inside, and those maps
//! can be of different types.
//!
//! It is used like this:
//!
//! ```
//! // keys define submaps of a `DynMap`
//! const STRING_TO_U32: Key<String, u32> = Key::new();
//! const U32_TO_VEC: Key<u32, Vec<bool>> = Key::new();
//!
//! // Note: concrete type, no type params!
//! let mut map = DynMap::new();
//!
//! // To access a specific map, index the `DynMap` by `Key`:
//! map[STRING_TO_U32].insert("hello".to_string(), 92);
//! let value = map[U32_TO_VEC].get(92);
//! assert!(value.is_none());
//! ```
//!
//! This is a work of fiction. Any similarities to Kotlin's `BindingContext` are
//! a coincidence.
use std::{
hash::Hash,
marker::PhantomData,
ops::{Index, IndexMut},
};
use anymap::Map;
use rustc_hash::FxHashMap;
pub struct Key<K, V, P = (K, V)> {
_phantom: PhantomData<(K, V, P)>,
}
impl<K, V, P> Key<K, V, P> {
pub(crate) const fn new() -> Key<K, V, P> {
Key { _phantom: PhantomData }
}
}
impl<K, V, P> Copy for Key<K, V, P> {}
impl<K, V, P> Clone for Key<K, V, P> {
fn clone(&self) -> Key<K, V, P> {
*self
}
}
pub trait Policy {
type K;
type V;
fn insert(map: &mut DynMap, key: Self::K, value: Self::V);
fn get<'a>(map: &'a DynMap, key: &Self::K) -> Option<&'a Self::V>;
}
impl<K: Hash + Eq + 'static, V: 'static> Policy for (K, V) {
type K = K;
type V = V;
fn insert(map: &mut DynMap, key: K, value: V) {
map.map.entry::<FxHashMap<K, V>>().or_insert_with(Default::default).insert(key, value);
}
fn get<'a>(map: &'a DynMap, key: &K) -> Option<&'a V> {
map.map.get::<FxHashMap<K, V>>()?.get(key)
}
}
pub struct DynMap {
pub(crate) map: Map,
}
impl Default for DynMap {
fn default() -> Self {
DynMap { map: Map::new() }
}
}
#[repr(transparent)]
pub struct KeyMap<KEY> {
map: DynMap,
_phantom: PhantomData<KEY>,
}
impl<P: Policy> KeyMap<Key<P::K, P::V, P>> {
pub fn insert(&mut self, key: P::K, value: P::V) {
P::insert(&mut self.map, key, value)
}
pub fn get(&self, key: &P::K) -> Option<&P::V> {
P::get(&self.map, key)
}
}
impl<P: Policy> Index<Key<P::K, P::V, P>> for DynMap {
type Output = KeyMap<Key<P::K, P::V, P>>;
fn index(&self, _key: Key<P::K, P::V, P>) -> &Self::Output {
// Safe due to `#[repr(transparent)]`.
unsafe { std::mem::transmute::<&DynMap, &KeyMap<Key<P::K, P::V, P>>>(self) }
}
}
impl<P: Policy> IndexMut<Key<P::K, P::V, P>> for DynMap {
fn index_mut(&mut self, _key: Key<P::K, P::V, P>) -> &mut Self::Output {
// Safe due to `#[repr(transparent)]`.
unsafe { std::mem::transmute::<&mut DynMap, &mut KeyMap<Key<P::K, P::V, P>>>(self) }
}
}
|
