1 use crate::lock::{RwLockReadGuard, RwLockWriteGuard};
2 use crate::HashMap;
3 use core::hash::{BuildHasher, Hash};
4 use core::ops::{Deref, DerefMut};
5 use std::collections::hash_map::RandomState;
6 use std::fmt::{Debug, Formatter};
7 
8 pub struct Ref<'a, K, V, S = RandomState> {
9     _guard: RwLockReadGuard<'a, HashMap<K, V, S>>,
10     k: *const K,
11     v: *const V,
12 }
13 
14 unsafe impl<'a, K: Eq + Hash + Sync, V: Sync, S: BuildHasher> Send for Ref<'a, K, V, S> {}
15 unsafe impl<'a, K: Eq + Hash + Sync, V: Sync, S: BuildHasher> Sync for Ref<'a, K, V, S> {}
16 
17 impl<'a, K: Eq + Hash, V, S: BuildHasher> Ref<'a, K, V, S> {
new( guard: RwLockReadGuard<'a, HashMap<K, V, S>>, k: *const K, v: *const V, ) -> Self18     pub(crate) unsafe fn new(
19         guard: RwLockReadGuard<'a, HashMap<K, V, S>>,
20         k: *const K,
21         v: *const V,
22     ) -> Self {
23         Self {
24             _guard: guard,
25             k,
26             v,
27         }
28     }
29 
key(&self) -> &K30     pub fn key(&self) -> &K {
31         self.pair().0
32     }
33 
value(&self) -> &V34     pub fn value(&self) -> &V {
35         self.pair().1
36     }
37 
pair(&self) -> (&K, &V)38     pub fn pair(&self) -> (&K, &V) {
39         unsafe { (&*self.k, &*self.v) }
40     }
41 
map<F, T>(self, f: F) -> MappedRef<'a, K, V, T, S> where F: FnOnce(&V) -> &T,42     pub fn map<F, T>(self, f: F) -> MappedRef<'a, K, V, T, S>
43     where
44         F: FnOnce(&V) -> &T,
45     {
46         MappedRef {
47             _guard: self._guard,
48             k: self.k,
49             v: f(unsafe { &*self.v }),
50         }
51     }
52 
try_map<F, T>(self, f: F) -> Result<MappedRef<'a, K, V, T, S>, Self> where F: FnOnce(&V) -> Option<&T>,53     pub fn try_map<F, T>(self, f: F) -> Result<MappedRef<'a, K, V, T, S>, Self>
54     where
55         F: FnOnce(&V) -> Option<&T>,
56     {
57         if let Some(v) = f(unsafe { &*self.v }) {
58             Ok(MappedRef {
59                 _guard: self._guard,
60                 k: self.k,
61                 v,
62             })
63         } else {
64             Err(self)
65         }
66     }
67 }
68 
69 impl<'a, K: Eq + Hash + Debug, V: Debug, S: BuildHasher> Debug for Ref<'a, K, V, S> {
fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result70     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
71         f.debug_struct("Ref")
72             .field("k", &self.k)
73             .field("v", &self.v)
74             .finish()
75     }
76 }
77 
78 impl<'a, K: Eq + Hash, V, S: BuildHasher> Deref for Ref<'a, K, V, S> {
79     type Target = V;
80 
deref(&self) -> &V81     fn deref(&self) -> &V {
82         self.value()
83     }
84 }
85 
86 pub struct RefMut<'a, K, V, S = RandomState> {
87     guard: RwLockWriteGuard<'a, HashMap<K, V, S>>,
88     k: *const K,
89     v: *mut V,
90 }
91 
92 unsafe impl<'a, K: Eq + Hash + Sync, V: Sync, S: BuildHasher> Send for RefMut<'a, K, V, S> {}
93 unsafe impl<'a, K: Eq + Hash + Sync, V: Sync, S: BuildHasher> Sync for RefMut<'a, K, V, S> {}
94 
95 impl<'a, K: Eq + Hash, V, S: BuildHasher> RefMut<'a, K, V, S> {
new( guard: RwLockWriteGuard<'a, HashMap<K, V, S>>, k: *const K, v: *mut V, ) -> Self96     pub(crate) unsafe fn new(
97         guard: RwLockWriteGuard<'a, HashMap<K, V, S>>,
98         k: *const K,
99         v: *mut V,
100     ) -> Self {
101         Self { guard, k, v }
102     }
103 
key(&self) -> &K104     pub fn key(&self) -> &K {
105         self.pair().0
106     }
107 
value(&self) -> &V108     pub fn value(&self) -> &V {
109         self.pair().1
110     }
111 
value_mut(&mut self) -> &mut V112     pub fn value_mut(&mut self) -> &mut V {
113         self.pair_mut().1
114     }
115 
pair(&self) -> (&K, &V)116     pub fn pair(&self) -> (&K, &V) {
117         unsafe { (&*self.k, &*self.v) }
118     }
119 
pair_mut(&mut self) -> (&K, &mut V)120     pub fn pair_mut(&mut self) -> (&K, &mut V) {
121         unsafe { (&*self.k, &mut *self.v) }
122     }
123 
downgrade(self) -> Ref<'a, K, V, S>124     pub fn downgrade(self) -> Ref<'a, K, V, S> {
125         unsafe { Ref::new(RwLockWriteGuard::downgrade(self.guard), self.k, self.v) }
126     }
127 
map<F, T>(self, f: F) -> MappedRefMut<'a, K, V, T, S> where F: FnOnce(&mut V) -> &mut T,128     pub fn map<F, T>(self, f: F) -> MappedRefMut<'a, K, V, T, S>
129     where
130         F: FnOnce(&mut V) -> &mut T,
131     {
132         MappedRefMut {
133             _guard: self.guard,
134             k: self.k,
135             v: f(unsafe { &mut *self.v }),
136         }
137     }
138 
try_map<F, T>(self, f: F) -> Result<MappedRefMut<'a, K, V, T, S>, Self> where F: FnOnce(&mut V) -> Option<&mut T>,139     pub fn try_map<F, T>(self, f: F) -> Result<MappedRefMut<'a, K, V, T, S>, Self>
140     where
141         F: FnOnce(&mut V) -> Option<&mut T>,
142     {
143         let v = match f(unsafe { &mut *(self.v as *mut _) }) {
144             Some(v) => v,
145             None => return Err(self),
146         };
147         let guard = self.guard;
148         let k = self.k;
149         Ok(MappedRefMut {
150             _guard: guard,
151             k,
152             v,
153         })
154     }
155 }
156 
157 impl<'a, K: Eq + Hash + Debug, V: Debug, S: BuildHasher> Debug for RefMut<'a, K, V, S> {
fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result158     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
159         f.debug_struct("RefMut")
160             .field("k", &self.k)
161             .field("v", &self.v)
162             .finish()
163     }
164 }
165 
166 impl<'a, K: Eq + Hash, V, S: BuildHasher> Deref for RefMut<'a, K, V, S> {
167     type Target = V;
168 
deref(&self) -> &V169     fn deref(&self) -> &V {
170         self.value()
171     }
172 }
173 
174 impl<'a, K: Eq + Hash, V, S: BuildHasher> DerefMut for RefMut<'a, K, V, S> {
deref_mut(&mut self) -> &mut V175     fn deref_mut(&mut self) -> &mut V {
176         self.value_mut()
177     }
178 }
179 
180 pub struct MappedRef<'a, K, V, T, S = RandomState> {
181     _guard: RwLockReadGuard<'a, HashMap<K, V, S>>,
182     k: *const K,
183     v: *const T,
184 }
185 
186 impl<'a, K: Eq + Hash, V, T, S: BuildHasher> MappedRef<'a, K, V, T, S> {
key(&self) -> &K187     pub fn key(&self) -> &K {
188         self.pair().0
189     }
190 
value(&self) -> &T191     pub fn value(&self) -> &T {
192         self.pair().1
193     }
194 
pair(&self) -> (&K, &T)195     pub fn pair(&self) -> (&K, &T) {
196         unsafe { (&*self.k, &*self.v) }
197     }
198 
map<F, T2>(self, f: F) -> MappedRef<'a, K, V, T2, S> where F: FnOnce(&T) -> &T2,199     pub fn map<F, T2>(self, f: F) -> MappedRef<'a, K, V, T2, S>
200     where
201         F: FnOnce(&T) -> &T2,
202     {
203         MappedRef {
204             _guard: self._guard,
205             k: self.k,
206             v: f(unsafe { &*self.v }),
207         }
208     }
209 
try_map<F, T2>(self, f: F) -> Result<MappedRef<'a, K, V, T2, S>, Self> where F: FnOnce(&T) -> Option<&T2>,210     pub fn try_map<F, T2>(self, f: F) -> Result<MappedRef<'a, K, V, T2, S>, Self>
211     where
212         F: FnOnce(&T) -> Option<&T2>,
213     {
214         let v = match f(unsafe { &*self.v }) {
215             Some(v) => v,
216             None => return Err(self),
217         };
218         let guard = self._guard;
219         Ok(MappedRef {
220             _guard: guard,
221             k: self.k,
222             v,
223         })
224     }
225 }
226 
227 impl<'a, K: Eq + Hash + Debug, V, T: Debug, S: BuildHasher> Debug for MappedRef<'a, K, V, T, S> {
fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result228     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
229         f.debug_struct("MappedRef")
230             .field("k", &self.k)
231             .field("v", &self.v)
232             .finish()
233     }
234 }
235 
236 impl<'a, K: Eq + Hash, V, T, S: BuildHasher> Deref for MappedRef<'a, K, V, T, S> {
237     type Target = T;
238 
deref(&self) -> &T239     fn deref(&self) -> &T {
240         self.value()
241     }
242 }
243 
244 impl<'a, K: Eq + Hash, V, T: std::fmt::Display> std::fmt::Display for MappedRef<'a, K, V, T> {
fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result245     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
246         std::fmt::Display::fmt(self.value(), f)
247     }
248 }
249 
250 impl<'a, K: Eq + Hash, V, T: AsRef<TDeref>, TDeref: ?Sized> AsRef<TDeref>
251     for MappedRef<'a, K, V, T>
252 {
as_ref(&self) -> &TDeref253     fn as_ref(&self) -> &TDeref {
254         self.value().as_ref()
255     }
256 }
257 
258 pub struct MappedRefMut<'a, K, V, T, S = RandomState> {
259     _guard: RwLockWriteGuard<'a, HashMap<K, V, S>>,
260     k: *const K,
261     v: *mut T,
262 }
263 
264 impl<'a, K: Eq + Hash, V, T, S: BuildHasher> MappedRefMut<'a, K, V, T, S> {
key(&self) -> &K265     pub fn key(&self) -> &K {
266         self.pair().0
267     }
268 
value(&self) -> &T269     pub fn value(&self) -> &T {
270         self.pair().1
271     }
272 
value_mut(&mut self) -> &mut T273     pub fn value_mut(&mut self) -> &mut T {
274         self.pair_mut().1
275     }
276 
pair(&self) -> (&K, &T)277     pub fn pair(&self) -> (&K, &T) {
278         unsafe { (&*self.k, &*self.v) }
279     }
280 
pair_mut(&mut self) -> (&K, &mut T)281     pub fn pair_mut(&mut self) -> (&K, &mut T) {
282         unsafe { (&*self.k, &mut *self.v) }
283     }
284 
map<F, T2>(self, f: F) -> MappedRefMut<'a, K, V, T2, S> where F: FnOnce(&mut T) -> &mut T2,285     pub fn map<F, T2>(self, f: F) -> MappedRefMut<'a, K, V, T2, S>
286     where
287         F: FnOnce(&mut T) -> &mut T2,
288     {
289         MappedRefMut {
290             _guard: self._guard,
291             k: self.k,
292             v: f(unsafe { &mut *self.v }),
293         }
294     }
295 
try_map<F, T2>(self, f: F) -> Result<MappedRefMut<'a, K, V, T2, S>, Self> where F: FnOnce(&mut T) -> Option<&mut T2>,296     pub fn try_map<F, T2>(self, f: F) -> Result<MappedRefMut<'a, K, V, T2, S>, Self>
297     where
298         F: FnOnce(&mut T) -> Option<&mut T2>,
299     {
300         let v = match f(unsafe { &mut *(self.v as *mut _) }) {
301             Some(v) => v,
302             None => return Err(self),
303         };
304         let guard = self._guard;
305         let k = self.k;
306         Ok(MappedRefMut {
307             _guard: guard,
308             k,
309             v,
310         })
311     }
312 }
313 
314 impl<'a, K: Eq + Hash + Debug, V, T: Debug, S: BuildHasher> Debug for MappedRefMut<'a, K, V, T, S> {
fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result315     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
316         f.debug_struct("MappedRefMut")
317             .field("k", &self.k)
318             .field("v", &self.v)
319             .finish()
320     }
321 }
322 
323 impl<'a, K: Eq + Hash, V, T, S: BuildHasher> Deref for MappedRefMut<'a, K, V, T, S> {
324     type Target = T;
325 
deref(&self) -> &T326     fn deref(&self) -> &T {
327         self.value()
328     }
329 }
330 
331 impl<'a, K: Eq + Hash, V, T, S: BuildHasher> DerefMut for MappedRefMut<'a, K, V, T, S> {
deref_mut(&mut self) -> &mut T332     fn deref_mut(&mut self) -> &mut T {
333         self.value_mut()
334     }
335 }
336