vendor/dashmap/src/mapref/one.rs

   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> {
  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
  69 impl<'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
  78 impl<'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
  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> {
  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
 157 impl<'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
 166 impl<'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
 174 impl<'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
 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> {
 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
 227 impl<'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
 236 impl<'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
 244 pub struct MappedRefMut<'a, K, V, T, S = RandomState> {
 245     _guard: RwLockWriteGuard<'a, HashMap<K, V, S>>,
 246     k: *const K,
 247     v: *mut T,
 248 }
 249
 250 impl<'a, K: Eq + Hash, V, T, S: BuildHasher> MappedRefMut<'a, K, V, T, S> {
 251     pub fn key(&self) -> &K {
 252         self.pair().0
 253     }
 254
 255     pub fn value(&self) -> &T {
 256         self.pair().1
 257     }
 258
 259     pub fn value_mut(&mut self) -> &mut T {
 260         self.pair_mut().1
 261     }
 262
 263     pub fn pair(&self) -> (&K, &T) {
 264         unsafe { (&*self.k, &*self.v) }
 265     }
 266
 267     pub fn pair_mut(&mut self) -> (&K, &mut T) {
 268         unsafe { (&*self.k, &mut *self.v) }
 269     }
 270
 271     pub fn map<F, T2>(self, f: F) -> MappedRefMut<'a, K, V, T2, S>
 272     where
 273         F: FnOnce(&mut T) -> &mut T2,
 274     {
 275         MappedRefMut {
 276             _guard: self._guard,
 277             k: self.k,
 278             v: f(unsafe { &mut *self.v }),
 279         }
 280     }
 281
 282     pub fn try_map<F, T2>(self, f: F) -> Result<MappedRefMut<'a, K, V, T2, S>, Self>
 283     where
 284         F: FnOnce(&mut T) -> Option<&mut T2>,
 285     {
 286         let v = match f(unsafe { &mut *(self.v as *mut _) }) {
 287             Some(v) => v,
 288             None => return Err(self),
 289         };
 290         let guard = self._guard;
 291         let k = self.k;
 292         Ok(MappedRefMut {
 293             _guard: guard,
 294             k,
 295             v,
 296         })
 297     }
 298 }
 299
 300 impl<'a, K: Eq + Hash + Debug, V, T: Debug, S: BuildHasher> Debug for MappedRefMut<'a, K, V, T, S> {
 301     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
 302         f.debug_struct("MappedRefMut")
 303             .field("k", &self.k)
 304             .field("v", &self.v)
 305             .finish()
 306     }
 307 }
 308
 309 impl<'a, K: Eq + Hash, V, T, S: BuildHasher> Deref for MappedRefMut<'a, K, V, T, S> {
 310     type Target = T;
 311
 312     fn deref(&self) -> &T {
 313         self.value()
 314     }
 315 }
 316
 317 impl<'a, K: Eq + Hash, V, T, S: BuildHasher> DerefMut for MappedRefMut<'a, K, V, T, S> {
 318     fn deref_mut(&mut self) -> &mut T {
 319         self.value_mut()
 320     }
 321 }