|
1 | 1 | use std::any::{Any, TypeId}; |
2 | | -use std::borrow::Borrow; |
3 | 2 | use std::cell::RefCell; |
4 | | -use std::cmp::Ordering; |
5 | 3 | use std::collections::HashMap; |
6 | | -use std::hash::{Hash, Hasher}; |
7 | | -use std::marker::PhantomData; |
8 | | -use std::ops::Deref; |
9 | | -use std::path::PathBuf; |
10 | | -use std::sync::{LazyLock, Mutex}; |
11 | | -use std::{fmt, mem}; |
12 | 4 |
|
13 | 5 | use crate::core::builder::Step; |
14 | 6 |
|
15 | | -pub struct Interned<T>(usize, PhantomData<*const T>); |
16 | | - |
17 | | -impl<T: Internable + Default> Default for Interned<T> { |
18 | | - fn default() -> Self { |
19 | | - T::default().intern() |
20 | | - } |
21 | | -} |
22 | | - |
23 | | -impl<T> Copy for Interned<T> {} |
24 | | -impl<T> Clone for Interned<T> { |
25 | | - fn clone(&self) -> Interned<T> { |
26 | | - *self |
27 | | - } |
28 | | -} |
29 | | - |
30 | | -impl<T> PartialEq for Interned<T> { |
31 | | - fn eq(&self, other: &Self) -> bool { |
32 | | - self.0 == other.0 |
33 | | - } |
34 | | -} |
35 | | -impl<T> Eq for Interned<T> {} |
36 | | - |
37 | | -impl PartialEq<str> for Interned<String> { |
38 | | - fn eq(&self, other: &str) -> bool { |
39 | | - *self == other |
40 | | - } |
41 | | -} |
42 | | -impl<'a> PartialEq<&'a str> for Interned<String> { |
43 | | - fn eq(&self, other: &&str) -> bool { |
44 | | - **self == **other |
45 | | - } |
46 | | -} |
47 | | -impl<'a, T> PartialEq<&'a Interned<T>> for Interned<T> { |
48 | | - fn eq(&self, other: &&Self) -> bool { |
49 | | - self.0 == other.0 |
50 | | - } |
51 | | -} |
52 | | -impl<'a, T> PartialEq<Interned<T>> for &'a Interned<T> { |
53 | | - fn eq(&self, other: &Interned<T>) -> bool { |
54 | | - self.0 == other.0 |
55 | | - } |
56 | | -} |
57 | | - |
58 | | -unsafe impl<T> Send for Interned<T> {} |
59 | | -unsafe impl<T> Sync for Interned<T> {} |
60 | | - |
61 | | -impl fmt::Display for Interned<String> { |
62 | | - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
63 | | - let s: &str = self; |
64 | | - f.write_str(s) |
65 | | - } |
66 | | -} |
67 | | - |
68 | | -impl<T, U: ?Sized + fmt::Debug> fmt::Debug for Interned<T> |
69 | | -where |
70 | | - Self: Deref<Target = U>, |
71 | | -{ |
72 | | - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
73 | | - let s: &U = self; |
74 | | - f.write_fmt(format_args!("{s:?}")) |
75 | | - } |
76 | | -} |
77 | | - |
78 | | -impl<T: Internable + Hash> Hash for Interned<T> { |
79 | | - fn hash<H: Hasher>(&self, state: &mut H) { |
80 | | - let l = T::intern_cache().lock().unwrap(); |
81 | | - l.get(*self).hash(state) |
82 | | - } |
83 | | -} |
84 | | - |
85 | | -impl<T: Internable + Deref> Deref for Interned<T> { |
86 | | - type Target = T::Target; |
87 | | - fn deref(&self) -> &Self::Target { |
88 | | - let l = T::intern_cache().lock().unwrap(); |
89 | | - unsafe { mem::transmute::<&Self::Target, &Self::Target>(l.get(*self)) } |
90 | | - } |
91 | | -} |
92 | | - |
93 | | -impl<T: Internable + AsRef<U>, U: ?Sized> AsRef<U> for Interned<T> { |
94 | | - fn as_ref(&self) -> &U { |
95 | | - let l = T::intern_cache().lock().unwrap(); |
96 | | - unsafe { mem::transmute::<&U, &U>(l.get(*self).as_ref()) } |
97 | | - } |
98 | | -} |
99 | | - |
100 | | -impl<T: Internable + PartialOrd> PartialOrd for Interned<T> { |
101 | | - fn partial_cmp(&self, other: &Self) -> Option<Ordering> { |
102 | | - let l = T::intern_cache().lock().unwrap(); |
103 | | - l.get(*self).partial_cmp(l.get(*other)) |
104 | | - } |
105 | | -} |
106 | | - |
107 | | -impl<T: Internable + Ord> Ord for Interned<T> { |
108 | | - fn cmp(&self, other: &Self) -> Ordering { |
109 | | - let l = T::intern_cache().lock().unwrap(); |
110 | | - l.get(*self).cmp(l.get(*other)) |
111 | | - } |
112 | | -} |
113 | | - |
114 | | -struct TyIntern<T: Clone + Eq> { |
115 | | - items: Vec<T>, |
116 | | - set: HashMap<T, Interned<T>>, |
117 | | -} |
118 | | - |
119 | | -impl<T: Hash + Clone + Eq> Default for TyIntern<T> { |
120 | | - fn default() -> Self { |
121 | | - TyIntern { items: Vec::new(), set: Default::default() } |
122 | | - } |
123 | | -} |
124 | | - |
125 | | -impl<T: Hash + Clone + Eq> TyIntern<T> { |
126 | | - fn intern_borrow<B>(&mut self, item: &B) -> Interned<T> |
127 | | - where |
128 | | - B: Eq + Hash + ToOwned<Owned = T> + ?Sized, |
129 | | - T: Borrow<B>, |
130 | | - { |
131 | | - if let Some(i) = self.set.get(item) { |
132 | | - return *i; |
133 | | - } |
134 | | - let item = item.to_owned(); |
135 | | - let interned = Interned(self.items.len(), PhantomData::<*const T>); |
136 | | - self.set.insert(item.clone(), interned); |
137 | | - self.items.push(item); |
138 | | - interned |
139 | | - } |
140 | | - |
141 | | - fn intern(&mut self, item: T) -> Interned<T> { |
142 | | - if let Some(i) = self.set.get(&item) { |
143 | | - return *i; |
144 | | - } |
145 | | - let interned = Interned(self.items.len(), PhantomData::<*const T>); |
146 | | - self.set.insert(item.clone(), interned); |
147 | | - self.items.push(item); |
148 | | - interned |
149 | | - } |
150 | | - |
151 | | - fn get(&self, i: Interned<T>) -> &T { |
152 | | - &self.items[i.0] |
153 | | - } |
154 | | -} |
155 | | - |
156 | | -#[derive(Default)] |
157 | | -pub struct Interner { |
158 | | - strs: Mutex<TyIntern<String>>, |
159 | | - paths: Mutex<TyIntern<PathBuf>>, |
160 | | - lists: Mutex<TyIntern<Vec<String>>>, |
161 | | -} |
162 | | - |
163 | | -trait Internable: Clone + Eq + Hash + 'static { |
164 | | - fn intern_cache() -> &'static Mutex<TyIntern<Self>>; |
165 | | - |
166 | | - fn intern(self) -> Interned<Self> { |
167 | | - Self::intern_cache().lock().unwrap().intern(self) |
168 | | - } |
169 | | -} |
170 | | - |
171 | | -impl Internable for String { |
172 | | - fn intern_cache() -> &'static Mutex<TyIntern<Self>> { |
173 | | - &INTERNER.strs |
174 | | - } |
175 | | -} |
176 | | - |
177 | | -impl Internable for PathBuf { |
178 | | - fn intern_cache() -> &'static Mutex<TyIntern<Self>> { |
179 | | - &INTERNER.paths |
180 | | - } |
181 | | -} |
182 | | - |
183 | | -impl Internable for Vec<String> { |
184 | | - fn intern_cache() -> &'static Mutex<TyIntern<Self>> { |
185 | | - &INTERNER.lists |
186 | | - } |
187 | | -} |
188 | | - |
189 | | -impl Interner { |
190 | | - pub fn intern_str(&self, s: &str) -> Interned<String> { |
191 | | - self.strs.lock().unwrap().intern_borrow(s) |
192 | | - } |
193 | | -} |
194 | | - |
195 | | -pub static INTERNER: LazyLock<Interner> = LazyLock::new(Interner::default); |
| 7 | +pub type Interned<T> = internment::Intern<T>; |
196 | 8 |
|
197 | 9 | /// This is essentially a `HashMap` which allows storing any type in its input and |
198 | 10 | /// any type in its output. It is a write-once cache; values are never evicted, |
|
0 commit comments