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