1use crate::lock::{RwLockReadGuard, RwLockWriteGuard};
2use crate::HashMap;
3use core::hash::{BuildHasher, Hash};
4use core::ops::{Deref, DerefMut};
5use std::collections::hash_map::RandomState;
6use std::fmt::{Debug, Formatter};
7
8pub 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
14unsafe impl<'a, K: Eq + Hash + Sync, V: Sync, S: BuildHasher> Send for Ref<'a, K, V, S> {}
15unsafe impl<'a, K: Eq + Hash + Sync, V: Sync, S: BuildHasher> Sync for Ref<'a, K, V, S> {}
16
17impl<'a, K: Eq + Hash, V, S: BuildHasher> Ref<'a, K, V, S> {
18 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
30 pub fn key(&self) -> &K {
31 self.pair().0
32 }
33
34 pub fn value(&self) -> &V {
35 self.pair().1
36 }
37
38 pub fn pair(&self) -> (&K, &V) {
39 unsafe { (&*self.k, &*self.v) }
40 }
41
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
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
69impl<'a, K: Eq + Hash + Debug, V: Debug, S: BuildHasher> Debug for Ref<'a, K, V, S> {
70 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
78impl<'a, K: Eq + Hash, V, S: BuildHasher> Deref for Ref<'a, K, V, S> {
79 type Target = V;
80
81 fn deref(&self) -> &V {
82 self.value()
83 }
84}
85
86pub 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
92unsafe impl<'a, K: Eq + Hash + Sync, V: Sync, S: BuildHasher> Send for RefMut<'a, K, V, S> {}
93unsafe impl<'a, K: Eq + Hash + Sync, V: Sync, S: BuildHasher> Sync for RefMut<'a, K, V, S> {}
94
95impl<'a, K: Eq + Hash, V, S: BuildHasher> RefMut<'a, K, V, S> {
96 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
104 pub fn key(&self) -> &K {
105 self.pair().0
106 }
107
108 pub fn value(&self) -> &V {
109 self.pair().1
110 }
111
112 pub fn value_mut(&mut self) -> &mut V {
113 self.pair_mut().1
114 }
115
116 pub fn pair(&self) -> (&K, &V) {
117 unsafe { (&*self.k, &*self.v) }
118 }
119
120 pub fn pair_mut(&mut self) -> (&K, &mut V) {
121 unsafe { (&*self.k, &mut *self.v) }
122 }
123
124 pub fn downgrade(self) -> Ref<'a, K, V, S> {
125 unsafe { Ref::new(RwLockWriteGuard::downgrade(self.guard), self.k, self.v) }
126 }
127
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
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
157impl<'a, K: Eq + Hash + Debug, V: Debug, S: BuildHasher> Debug for RefMut<'a, K, V, S> {
158 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
166impl<'a, K: Eq + Hash, V, S: BuildHasher> Deref for RefMut<'a, K, V, S> {
167 type Target = V;
168
169 fn deref(&self) -> &V {
170 self.value()
171 }
172}
173
174impl<'a, K: Eq + Hash, V, S: BuildHasher> DerefMut for RefMut<'a, K, V, S> {
175 fn deref_mut(&mut self) -> &mut V {
176 self.value_mut()
177 }
178}
179
180pub 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
186impl<'a, K: Eq + Hash, V, T, S: BuildHasher> MappedRef<'a, K, V, T, S> {
187 pub fn key(&self) -> &K {
188 self.pair().0
189 }
190
191 pub fn value(&self) -> &T {
192 self.pair().1
193 }
194
195 pub fn pair(&self) -> (&K, &T) {
196 unsafe { (&*self.k, &*self.v) }
197 }
198
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
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
227impl<'a, K: Eq + Hash + Debug, V, T: Debug, S: BuildHasher> Debug for MappedRef<'a, K, V, T, S> {
228 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
236impl<'a, K: Eq + Hash, V, T, S: BuildHasher> Deref for MappedRef<'a, K, V, T, S> {
237 type Target = T;
238
239 fn deref(&self) -> &T {
240 self.value()
241 }
242}
243
244impl<'a, K: Eq + Hash, V, T: std::fmt::Display> std::fmt::Display for MappedRef<'a, K, V, T> {
245 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
246 std::fmt::Display::fmt(self.value(), f)
247 }
248}
249
250impl<'a, K: Eq + Hash, V, T: AsRef<TDeref>, TDeref: ?Sized> AsRef<TDeref>
251 for MappedRef<'a, K, V, T>
252{
253 fn as_ref(&self) -> &TDeref {
254 self.value().as_ref()
255 }
256}
257
258pub 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
264impl<'a, K: Eq + Hash, V, T, S: BuildHasher> MappedRefMut<'a, K, V, T, S> {
265 pub fn key(&self) -> &K {
266 self.pair().0
267 }
268
269 pub fn value(&self) -> &T {
270 self.pair().1
271 }
272
273 pub fn value_mut(&mut self) -> &mut T {
274 self.pair_mut().1
275 }
276
277 pub fn pair(&self) -> (&K, &T) {
278 unsafe { (&*self.k, &*self.v) }
279 }
280
281 pub fn pair_mut(&mut self) -> (&K, &mut T) {
282 unsafe { (&*self.k, &mut *self.v) }
283 }
284
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
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
314impl<'a, K: Eq + Hash + Debug, V, T: Debug, S: BuildHasher> Debug for MappedRefMut<'a, K, V, T, S> {
315 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
323impl<'a, K: Eq + Hash, V, T, S: BuildHasher> Deref for MappedRefMut<'a, K, V, T, S> {
324 type Target = T;
325
326 fn deref(&self) -> &T {
327 self.value()
328 }
329}
330
331impl<'a, K: Eq + Hash, V, T, S: BuildHasher> DerefMut for MappedRefMut<'a, K, V, T, S> {
332 fn deref_mut(&mut self) -> &mut T {
333 self.value_mut()
334 }
335}