Add Ref/RefMut::map_split

Closes #337

Author: yshui

src/mapref/multiple.rs

@@ -3,13 +3,13 @@ use core::hash::Hash;
 use core::ops::{Deref, DerefMut};
 use std::sync::Arc;
 
-pub struct RefMulti<'a, K, V> {
-    _guard: Arc<RwLockReadGuardDetached<'a>>,
-    k: &'a K,
-    v: &'a V,
+pub struct RefMulti<'a, K, V: ?Sized> {
+    pub(super) _guard: Arc<RwLockReadGuardDetached<'a>>,
+    pub(super) k: &'a K,
+    pub(super) v: &'a V,
 }
 
-impl<'a, K: Eq + Hash, V> RefMulti<'a, K, V> {
+impl<'a, K: Eq + Hash, V: ?Sized> RefMulti<'a, K, V> {
     pub(crate) fn new(guard: Arc<RwLockReadGuardDetached<'a>>, k: &'a K, v: &'a V) -> Self {
         Self {
             _guard: guard,
@@ -31,21 +31,21 @@ impl<'a, K: Eq + Hash, V> RefMulti<'a, K, V> {
     }
 }
 
-impl<'a, K: Eq + Hash, V> Deref for RefMulti<'a, K, V> {
+impl<'a, K: Eq + Hash, V: ?Sized> Deref for RefMulti<'a, K, V> {
     type Target = V;
 
     fn deref(&self) -> &V {
         self.value()
     }
 }
 
-pub struct RefMutMulti<'a, K, V> {
-    _guard: Arc<RwLockWriteGuardDetached<'a>>,
-    k: &'a K,
-    v: &'a mut V,
+pub struct RefMutMulti<'a, K, V: ?Sized> {
+    pub(super) _guard: Arc<RwLockWriteGuardDetached<'a>>,
+    pub(super) k: &'a K,
+    pub(super) v: &'a mut V,
 }
 
-impl<'a, K: Eq + Hash, V> RefMutMulti<'a, K, V> {
+impl<'a, K: Eq + Hash, V: ?Sized> RefMutMulti<'a, K, V> {
     pub(crate) fn new(guard: Arc<RwLockWriteGuardDetached<'a>>, k: &'a K, v: &'a mut V) -> Self {
         Self {
             _guard: guard,
@@ -75,15 +75,15 @@ impl<'a, K: Eq + Hash, V> RefMutMulti<'a, K, V> {
     }
 }
 
-impl<'a, K: Eq + Hash, V> Deref for RefMutMulti<'a, K, V> {
+impl<'a, K: Eq + Hash, V: ?Sized> Deref for RefMutMulti<'a, K, V> {
     type Target = V;
 
     fn deref(&self) -> &V {
         self.value()
     }
 }
 
-impl<'a, K: Eq + Hash, V> DerefMut for RefMutMulti<'a, K, V> {
+impl<'a, K: Eq + Hash, V: ?Sized> DerefMut for RefMutMulti<'a, K, V> {
     fn deref_mut(&mut self) -> &mut V {
         self.value_mut()
     }

src/mapref/one.rs

@@ -1,7 +1,13 @@
-use crate::lock::{RwLockReadGuardDetached, RwLockWriteGuardDetached};
+use crate::{
+    lock::{RwLockReadGuardDetached, RwLockWriteGuardDetached},
+    mapref::multiple::{RefMulti, RefMutMulti},
+};
 use core::hash::Hash;
 use core::ops::{Deref, DerefMut};
-use std::fmt::{Debug, Formatter};
+use std::{
+    fmt::{Debug, Formatter},
+    sync::Arc,
+};
 
 pub struct Ref<'a, K, V> {
     _guard: RwLockReadGuardDetached<'a>,
@@ -55,6 +61,29 @@ impl<'a, K: Eq + Hash, V> Ref<'a, K, V> {
             Err(self)
         }
     }
+
+    pub fn map_split<F, A: ?Sized, B: ?Sized>(
+        self,
+        f: F,
+    ) -> (RefMulti<'a, K, A>, RefMulti<'a, K, B>)
+    where
+        F: FnOnce(&V) -> (&A, &B),
+    {
+        let (a, b) = f(self.v);
+        let guard = Arc::new(self._guard);
+        (
+            RefMulti {
+                _guard: guard.clone(),
+                k: self.k,
+                v: a,
+            },
+            RefMulti {
+                _guard: guard,
+                k: self.k,
+                v: b,
+            },
+        )
+    }
 }
 
 impl<'a, K: Eq + Hash + Debug, V: Debug> Debug for Ref<'a, K, V> {
@@ -140,6 +169,29 @@ impl<'a, K: Eq + Hash, V> RefMut<'a, K, V> {
             v,
         })
     }
+
+    pub fn map_split<F, A: ?Sized, B: ?Sized>(
+        self,
+        f: F,
+    ) -> (RefMutMulti<'a, K, A>, RefMutMulti<'a, K, B>)
+    where
+        F: FnOnce(&mut V) -> (&mut A, &mut B),
+    {
+        let (a, b) = f(self.v);
+        let guard = Arc::new(self.guard);
+        (
+            RefMutMulti {
+                _guard: guard.clone(),
+                k: self.k,
+                v: a,
+            },
+            RefMutMulti {
+                _guard: guard,
+                k: self.k,
+                v: b,
+            },
+        )
+    }
 }
 
 impl<'a, K: Eq + Hash + Debug, V: Debug> Debug for RefMut<'a, K, V> {