make explicit

xacrimon · Feb 6, 2022 · f01fc75 · f01fc75
1 parent 45c7a3c
commit f01fc75
Show file tree

Hide file tree

Showing 4 changed files with 47 additions and 46 deletions.
diff --git a/src/lib.rs b/src/lib.rs
@@ -993,9 +993,7 @@ impl<'a, K: 'a + Eq + Hash, V: 'a, S: 'a + BuildHasher + Clone> Map<'a, K, V, S>
         if let Some((kptr, vptr)) = shard.get_key_value(&key) {
             unsafe {
                 let kptr = util::change_lifetime_const(kptr);
-
                 let vptr = &mut *vptr.as_ptr();
-
                 Entry::Occupied(OccupiedEntry::new(shard, key, (kptr, vptr)))
             }
         } else {

diff --git a/src/mapref/entry.rs b/src/mapref/entry.rs
@@ -132,7 +132,7 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> VacantEntry<'a, K, V, S> {
 
 pub struct OccupiedEntry<'a, K, V, S> {
     shard: RwLockWriteGuard<'a, HashMap<K, V, S>>,
-    elem: (&'a K, &'a mut V),
+    elem: (*const K, *mut V),
     key: K,
 }
 
@@ -147,21 +147,21 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> OccupiedEntry<'a, K, V, S> {
     pub(crate) fn new(
         shard: RwLockWriteGuard<'a, HashMap<K, V, S>>,
         key: K,
-        elem: (&'a K, &'a mut V),
+        elem: (*const K, *mut V),
     ) -> Self {
         Self { shard, elem, key }
     }
 
     pub fn get(&self) -> &V {
-        self.elem.1
+        unsafe { &*self.elem.1 }
     }
 
     pub fn get_mut(&mut self) -> &mut V {
-        self.elem.1
+        unsafe { &mut *self.elem.1 }
     }
 
     pub fn insert(&mut self, value: V) -> V {
-        mem::replace(self.elem.1, value)
+        mem::replace(self.get_mut(), value)
     }
 
     pub fn into_ref(self) -> RefMut<'a, K, V, S> {
@@ -173,26 +173,25 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> OccupiedEntry<'a, K, V, S> {
     }
 
     pub fn key(&self) -> &K {
-        self.elem.0
+        unsafe { &*self.elem.0 }
     }
 
     pub fn remove(mut self) -> V {
-        self.shard.remove(self.elem.0).unwrap().into_inner()
+        let key = unsafe { &*self.elem.0 };
+        self.shard.remove(key).unwrap().into_inner()
     }
 
     pub fn remove_entry(mut self) -> (K, V) {
-        let (k, v) = self.shard.remove_entry(self.elem.0).unwrap();
-
+        let key = unsafe { &*self.elem.0 };
+        let (k, v) = self.shard.remove_entry(key).unwrap();
         (k, v.into_inner())
     }
 
     pub fn replace_entry(mut self, value: V) -> (K, V) {
         let nk = self.key;
-
-        let (k, v) = self.shard.remove_entry(self.elem.0).unwrap();
-
+        let key = unsafe { &*self.elem.0 };
+        let (k, v) = self.shard.remove_entry(key).unwrap();
         self.shard.insert(nk, SharedValue::new(value));
-
         (k, v.into_inner())
     }
 }
diff --git a/src/mapref/multiple.rs b/src/mapref/multiple.rs
@@ -8,8 +8,8 @@ use std::sync::Arc;
 
 pub struct RefMulti<'a, K, V, S = RandomState> {
     _guard: Arc<RwLockReadGuard<'a, HashMap<K, V, S>>>,
-    k: &'a K,
-    v: &'a V,
+    k: *const K,
+    v: *const V,
 }
 
 unsafe impl<'a, K: Eq + Hash + Send, V: Send, S: BuildHasher> Send for RefMulti<'a, K, V, S> {}
@@ -22,8 +22,8 @@ unsafe impl<'a, K: Eq + Hash + Send + Sync, V: Send + Sync, S: BuildHasher> Sync
 impl<'a, K: Eq + Hash, V, S: BuildHasher> RefMulti<'a, K, V, S> {
     pub(crate) fn new(
         guard: Arc<RwLockReadGuard<'a, HashMap<K, V, S>>>,
-        k: &'a K,
-        v: &'a V,
+        k: *const K,
+        v: *const V,
     ) -> Self {
         Self {
             _guard: guard,
@@ -33,15 +33,15 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> RefMulti<'a, K, V, S> {
     }
 
     pub fn key(&self) -> &K {
-        self.k
+        self.pair().0
     }
 
     pub fn value(&self) -> &V {
-        self.v
+        self.pair().1
     }
 
     pub fn pair(&self) -> (&K, &V) {
-        (self.k, self.v)
+        unsafe { (&*self.k, &*self.v) }
     }
 }
 
@@ -55,8 +55,8 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> Deref for RefMulti<'a, K, V, S> {
 
 pub struct RefMutMulti<'a, K, V, S = RandomState> {
     _guard: Arc<RwLockWriteGuard<'a, HashMap<K, V, S>>>,
-    k: &'a K,
-    v: &'a mut V,
+    k: *const K,
+    v: *mut V,
 }
 
 unsafe impl<'a, K: Eq + Hash + Send, V: Send, S: BuildHasher> Send for RefMutMulti<'a, K, V, S> {}
@@ -69,8 +69,8 @@ unsafe impl<'a, K: Eq + Hash + Send + Sync, V: Send + Sync, S: BuildHasher> Sync
 impl<'a, K: Eq + Hash, V, S: BuildHasher> RefMutMulti<'a, K, V, S> {
     pub(crate) fn new(
         guard: Arc<RwLockWriteGuard<'a, HashMap<K, V, S>>>,
-        k: &'a K,
-        v: &'a mut V,
+        k: *const K,
+        v: *mut V,
     ) -> Self {
         Self {
             _guard: guard,
@@ -80,23 +80,23 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> RefMutMulti<'a, K, V, S> {
     }
 
     pub fn key(&self) -> &K {
-        self.k
+        self.pair().0
     }
 
     pub fn value(&self) -> &V {
-        self.v
+        self.pair().1
     }
 
     pub fn value_mut(&mut self) -> &mut V {
-        self.v
+        self.pair_mut().1
     }
 
     pub fn pair(&self) -> (&K, &V) {
-        (self.k, self.v)
+        unsafe { (&*self.k, &*self.v) }
     }
 
     pub fn pair_mut(&mut self) -> (&K, &mut V) {
-        (self.k, self.v)
+        unsafe { (&*self.k, &mut *self.v) }
     }
 }
 

diff --git a/src/mapref/one.rs b/src/mapref/one.rs
@@ -6,8 +6,8 @@ use std::collections::hash_map::RandomState;
 
 pub struct Ref<'a, K, V, S = RandomState> {
     _guard: RwLockReadGuard<'a, HashMap<K, V, S>>,
-    k: &'a K,
-    v: &'a V,
+    k: *const K,
+    v: *const V,
 }
 
 unsafe impl<'a, K: Eq + Hash + Send, V: Send, S: BuildHasher> Send for Ref<'a, K, V, S> {}
@@ -18,7 +18,11 @@ unsafe impl<'a, K: Eq + Hash + Send + Sync, V: Send + Sync, S: BuildHasher> Sync
 }
 
 impl<'a, K: Eq + Hash, V, S: BuildHasher> Ref<'a, K, V, S> {
-    pub(crate) fn new(guard: RwLockReadGuard<'a, HashMap<K, V, S>>, k: &'a K, v: &'a V) -> Self {
+    pub(crate) fn new(
+        guard: RwLockReadGuard<'a, HashMap<K, V, S>>,
+        k: *const K,
+        v: *const V,
+    ) -> Self {
         Self {
             _guard: guard,
             k,
@@ -27,15 +31,15 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> Ref<'a, K, V, S> {
     }
 
     pub fn key(&self) -> &K {
-        self.k
+        self.pair().0
     }
 
     pub fn value(&self) -> &V {
-        self.v
+        self.pair().1
     }
 
     pub fn pair(&self) -> (&K, &V) {
-        (self.k, self.v)
+        unsafe { (&*self.k, &*self.v) }
     }
 }
 
@@ -49,8 +53,8 @@ impl<'a, K: Eq + Hash, V, S: BuildHasher> Deref for Ref<'a, K, V, S> {
 
 pub struct RefMut<'a, K, V, S = RandomState> {
     guard: RwLockWriteGuard<'a, HashMap<K, V, S>>,
-    k: &'a K,
-    v: &'a mut V,
+    k: *const K,
+    v: *mut V,
 }
 
 unsafe impl<'a, K: Eq + Hash + Send, V: Send, S: BuildHasher> Send for RefMut<'a, K, V, S> {}
@@ -63,30 +67,30 @@ unsafe impl<'a, K: Eq + Hash + Send + Sync, V: Send + Sync, S: BuildHasher> Sync
 impl<'a, K: Eq + Hash, V, S: BuildHasher> RefMut<'a, K, V, S> {
     pub(crate) fn new(
         guard: RwLockWriteGuard<'a, HashMap<K, V, S>>,
-        k: &'a K,
-        v: &'a mut V,
+        k: *const K,
+        v: *mut V,
     ) -> Self {
         Self { guard, k, v }
     }
 
     pub fn key(&self) -> &K {
-        self.k
+        self.pair().0
     }
 
     pub fn value(&self) -> &V {
-        self.v
+        self.pair().1
     }
 
     pub fn value_mut(&mut self) -> &mut V {
-        self.v
+        self.pair_mut().1
     }
 
     pub fn pair(&self) -> (&K, &V) {
-        (self.k, self.v)
+        unsafe { (&*self.k, &*self.v) }
     }
 
     pub fn pair_mut(&mut self) -> (&K, &mut V) {
-        (self.k, self.v)
+        unsafe { (&*self.k, &mut *self.v) }
     }
 
     pub fn downgrade(self) -> Ref<'a, K, V, S> {