Mapped Ref and RefMut (#203)

Co-authored-by: Artem Shein <artem.shein@esrlabs.com>

src/mapref/one.rs

@@ -3,6 +3,7 @@ use crate::HashMap;
 use core::hash::{BuildHasher, Hash};
 use core::ops::{Deref, DerefMut};
 use std::collections::hash_map::RandomState;
+use std::fmt::{Debug, Formatter};
 
 pub struct Ref<'a, K, V, S = RandomState> {
     _guard: RwLockReadGuard<'a, HashMap<K, V, S>>,
@@ -37,6 +38,41 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> Ref<'a, K, V, S> {
     pub fn pair(&self) -> (&K, &V) {
         unsafe { (&*self.k, &*self.v) }
     }
+
+    pub fn map<F, T>(self, f: F) -> MappedRef<'a, K, V, T, S>
+    where
+        F: FnOnce(&V) -> &T,
+    {
+        MappedRef {
+            _guard: self._guard,
+            k: self.k,
+            v: f(unsafe { &*self.v }),
+        }
+    }
+
+    pub fn try_map<F, T>(self, f: F) -> Result<MappedRef<'a, K, V, T, S>, Self>
+    where
+        F: FnOnce(&V) -> Option<&T>,
+    {
+        if let Some(v) = f(unsafe { &*self.v }) {
+            Ok(MappedRef {
+                _guard: self._guard,
+                k: self.k,
+                v,
+            })
+        } else {
+            Err(self)
+        }
+    }
+}
+
+impl<'a, K: Eq + Hash + Debug, V: Debug, S: BuildHasher> Debug for Ref<'a, K, V, S> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Ref")
+            .field("k", &self.k)
+            .field("v", &self.v)
+            .finish()
+    }
 }
 
 impl<'a, K: Eq + Hash, V, S: BuildHasher> Deref for Ref<'a, K, V, S> {
@@ -88,6 +124,43 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> RefMut<'a, K, V, S> {
     pub fn downgrade(self) -> Ref<'a, K, V, S> {
         unsafe { Ref::new(RwLockWriteGuard::downgrade(self.guard), self.k, self.v) }
     }
+
+    pub fn map<F, T>(self, f: F) -> MappedRefMut<'a, K, V, T, S>
+    where
+        F: FnOnce(&mut V) -> &mut T,
+    {
+        MappedRefMut {
+            _guard: self.guard,
+            k: self.k,
+            v: f(unsafe { &mut *self.v }),
+        }
+    }
+
+    pub fn try_map<F, T>(self, f: F) -> Result<MappedRefMut<'a, K, V, T, S>, Self>
+    where
+        F: FnOnce(&mut V) -> Option<&mut T>,
+    {
+        let v = match f(unsafe { &mut *(self.v as *mut _) }) {
+            Some(v) => v,
+            None => return Err(self),
+        };
+        let guard = self.guard;
+        let k = self.k;
+        Ok(MappedRefMut {
+            _guard: guard,
+            k,
+            v,
+        })
+    }
+}
+
+impl<'a, K: Eq + Hash + Debug, V: Debug, S: BuildHasher> Debug for RefMut<'a, K, V, S> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("RefMut")
+            .field("k", &self.k)
+            .field("v", &self.v)
+            .finish()
+    }
 }
 
 impl<'a, K: Eq + Hash, V, S: BuildHasher> Deref for RefMut<'a, K, V, S> {
@@ -103,3 +176,146 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> DerefMut for RefMut<'a, K, V, S> {
         self.value_mut()
     }
 }
+
+pub struct MappedRef<'a, K, V, T, S = RandomState> {
+    _guard: RwLockReadGuard<'a, HashMap<K, V, S>>,
+    k: *const K,
+    v: *const T,
+}
+
+impl<'a, K: Eq + Hash, V, T, S: BuildHasher> MappedRef<'a, K, V, T, S> {
+    pub fn key(&self) -> &K {
+        self.pair().0
+    }
+
+    pub fn value(&self) -> &T {
+        self.pair().1
+    }
+
+    pub fn pair(&self) -> (&K, &T) {
+        unsafe { (&*self.k, &*self.v) }
+    }
+
+    pub fn map<F, T2>(self, f: F) -> MappedRef<'a, K, V, T2, S>
+    where
+        F: FnOnce(&T) -> &T2,
+    {
+        MappedRef {
+            _guard: self._guard,
+            k: self.k,
+            v: f(unsafe { &*self.v }),
+        }
+    }
+
+    pub fn try_map<F, T2>(self, f: F) -> Result<MappedRef<'a, K, V, T2, S>, Self>
+    where
+        F: FnOnce(&T) -> Option<&T2>,
+    {
+        let v = match f(unsafe { &*self.v }) {
+            Some(v) => v,
+            None => return Err(self),
+        };
+        let guard = self._guard;
+        Ok(MappedRef {
+            _guard: guard,
+            k: self.k,
+            v,
+        })
+    }
+}
+
+impl<'a, K: Eq + Hash + Debug, V, T: Debug, S: BuildHasher> Debug for MappedRef<'a, K, V, T, S> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("MappedRef")
+            .field("k", &self.k)
+            .field("v", &self.v)
+            .finish()
+    }
+}
+
+impl<'a, K: Eq + Hash, V, T, S: BuildHasher> Deref for MappedRef<'a, K, V, T, S> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        self.value()
+    }
+}
+
+pub struct MappedRefMut<'a, K, V, T, S = RandomState> {
+    _guard: RwLockWriteGuard<'a, HashMap<K, V, S>>,
+    k: *const K,
+    v: *mut T,
+}
+
+impl<'a, K: Eq + Hash, V, T, S: BuildHasher> MappedRefMut<'a, K, V, T, S> {
+    pub fn key(&self) -> &K {
+        self.pair().0
+    }
+
+    pub fn value(&self) -> &T {
+        self.pair().1
+    }
+
+    pub fn value_mut(&mut self) -> &mut T {
+        self.pair_mut().1
+    }
+
+    pub fn pair(&self) -> (&K, &T) {
+        unsafe { (&*self.k, &*self.v) }
+    }
+
+    pub fn pair_mut(&mut self) -> (&K, &mut T) {
+        unsafe { (&*self.k, &mut *self.v) }
+    }
+
+    pub fn map<F, T2>(self, f: F) -> MappedRefMut<'a, K, V, T2, S>
+    where
+        F: FnOnce(&mut T) -> &mut T2,
+    {
+        MappedRefMut {
+            _guard: self._guard,
+            k: self.k,
+            v: f(unsafe { &mut *self.v }),
+        }
+    }
+
+    pub fn try_map<F, T2>(self, f: F) -> Result<MappedRefMut<'a, K, V, T2, S>, Self>
+    where
+        F: FnOnce(&mut T) -> Option<&mut T2>,
+    {
+        let v = match f(unsafe { &mut *(self.v as *mut _) }) {
+            Some(v) => v,
+            None => return Err(self),
+        };
+        let guard = self._guard;
+        let k = self.k;
+        Ok(MappedRefMut {
+            _guard: guard,
+            k,
+            v,
+        })
+    }
+}
+
+impl<'a, K: Eq + Hash + Debug, V, T: Debug, S: BuildHasher> Debug for MappedRefMut<'a, K, V, T, S> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("MappedRefMut")
+            .field("k", &self.k)
+            .field("v", &self.v)
+            .finish()
+    }
+}
+
+impl<'a, K: Eq + Hash, V, T, S: BuildHasher> Deref for MappedRefMut<'a, K, V, T, S> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        self.value()
+    }
+}
+
+impl<'a, K: Eq + Hash, V, T, S: BuildHasher> DerefMut for MappedRefMut<'a, K, V, T, S> {
+    fn deref_mut(&mut self) -> &mut T {
+        self.value_mut()
+    }
+}