Simplify StorageReader

storage/src/memory_backend.rs

@@ -5,7 +5,7 @@ use crate::{
   storage_backend::StorageError,
   storage_ptr::StorageEntryPtr,
   storage_tx::{StorageReader, StorageTxMut},
-  StorageAutoPtr, StorageBackend, StorageEntity, StoragePtr,
+  StorageBackend, StoragePtr,
 };
 
 #[derive(Default)]
@@ -92,15 +92,8 @@ impl StorageReader<'_, MemoryBackend> for MemoryTx<'_> {
     Ok(self.storage.data.get(&ptr.data).cloned())
   }
 
-  fn get_auto_ptr<SE: StorageEntity<MemoryBackend>>(
-    &mut self,
-    ptr: StorageEntryPtr,
-  ) -> StorageAutoPtr<MemoryBackend, SE> {
-    StorageAutoPtr {
-      _marker: std::marker::PhantomData,
-      sb: self.backend.clone(),
-      ptr,
-    }
+  fn get_backend(&self) -> Weak<RefCell<MemoryBackend>> {
+    self.backend.clone()
   }
 }
 
@@ -111,15 +104,7 @@ pub struct MemoryTxMut<'a> {
   storage: &'a mut MemoryBackend,
 }
 
-impl<'a> StorageTxMut<'a, MemoryBackend> for MemoryTxMut<'a> {
-  fn ref_deltas(&mut self) -> &mut HashMap<(u64, u64, u64), i64> {
-    &mut self.ref_deltas
-  }
-
-  fn cache(&mut self) -> &mut HashMap<RcKey, StorageEntryPtr> {
-    &mut self.cache
-  }
-
+impl<'a> StorageReader<'a, MemoryBackend> for MemoryTxMut<'a> {
   fn read_bytes<T>(
     &self,
     ptr: StoragePtr<T>,
@@ -127,15 +112,18 @@ impl<'a> StorageTxMut<'a, MemoryBackend> for MemoryTxMut<'a> {
     Ok(self.storage.data.get(&ptr.data).cloned())
   }
 
-  fn get_auto_ptr<SE: StorageEntity<MemoryBackend>>(
-    &mut self,
-    ptr: StorageEntryPtr,
-  ) -> StorageAutoPtr<MemoryBackend, SE> {
-    StorageAutoPtr {
-      _marker: std::marker::PhantomData,
-      sb: self.backend.clone(),
-      ptr,
-    }
+  fn get_backend(&self) -> Weak<RefCell<MemoryBackend>> {
+    self.backend.clone()
+  }
+}
+
+impl<'a> StorageTxMut<'a, MemoryBackend> for MemoryTxMut<'a> {
+  fn ref_deltas(&mut self) -> &mut HashMap<(u64, u64, u64), i64> {
+    &mut self.ref_deltas
+  }
+
+  fn cache(&mut self) -> &mut HashMap<RcKey, StorageEntryPtr> {
+    &mut self.cache
   }
 
   fn write_bytes<T>(

storage/src/sled_backend.rs

@@ -5,7 +5,7 @@ use crate::{
   storage_backend::StorageError,
   storage_ptr::StorageEntryPtr,
   storage_tx::{StorageReader, StorageTxMut},
-  StorageAutoPtr, StorageBackend, StorageEntity, StoragePtr,
+  StorageBackend, StoragePtr,
 };
 
 pub struct SledBackend {
@@ -122,15 +122,8 @@ impl<'a> StorageReader<'a, SledBackend> for SledTx<'a> {
     Ok(value)
   }
 
-  fn get_auto_ptr<SE: StorageEntity<SledBackend>>(
-    &mut self,
-    ptr: StorageEntryPtr,
-  ) -> crate::StorageAutoPtr<SledBackend, SE> {
-    StorageAutoPtr {
-      _marker: std::marker::PhantomData,
-      sb: self.backend.clone(),
-      ptr,
-    }
+  fn get_backend(&self) -> Weak<RefCell<SledBackend>> {
+    self.backend.clone()
   }
 }
 
@@ -141,15 +134,7 @@ pub struct SledTxMut<'a> {
   tx: &'a sled::transaction::TransactionalTree,
 }
 
-impl<'a> StorageTxMut<'a, SledBackend> for SledTxMut<'a> {
-  fn ref_deltas(&mut self) -> &mut HashMap<(u64, u64, u64), i64> {
-    &mut self.ref_deltas
-  }
-
-  fn cache(&mut self) -> &mut HashMap<RcKey, StorageEntryPtr> {
-    &mut self.cache
-  }
-
+impl<'a> StorageReader<'a, SledBackend> for SledTxMut<'a> {
   fn read_bytes<T>(
     &self,
     ptr: StoragePtr<T>,
@@ -163,15 +148,18 @@ impl<'a> StorageTxMut<'a, SledBackend> for SledTxMut<'a> {
     Ok(value)
   }
 
-  fn get_auto_ptr<SE: StorageEntity<SledBackend>>(
-    &mut self,
-    ptr: StorageEntryPtr,
-  ) -> crate::StorageAutoPtr<SledBackend, SE> {
-    StorageAutoPtr {
-      _marker: std::marker::PhantomData,
-      sb: self.backend.clone(),
-      ptr,
-    }
+  fn get_backend(&self) -> Weak<RefCell<SledBackend>> {
+    self.backend.clone()
+  }
+}
+
+impl<'a> StorageTxMut<'a, SledBackend> for SledTxMut<'a> {
+  fn ref_deltas(&mut self) -> &mut HashMap<(u64, u64, u64), i64> {
+    &mut self.ref_deltas
+  }
+
+  fn cache(&mut self) -> &mut HashMap<RcKey, StorageEntryPtr> {
+    &mut self.cache
   }
 
   fn write_bytes<T>(

storage/src/storage.rs

@@ -76,13 +76,13 @@ impl<SB: StorageBackend> Storage<SB> {
       .sb
       .borrow_mut()
       .transaction_mut(Rc::downgrade(&self.sb), |sb| {
-        let tmp_count = StorageTxMut::read(sb, tmp_count_ptr())?.unwrap_or(0);
+        let tmp_count = sb.read(tmp_count_ptr())?.unwrap_or(0);
         let tmp_ptr = tmp_at_ptr(tmp_count);
         sb.set_head(tmp_ptr, value)?;
 
         sb.write(tmp_count_ptr(), Some(&(tmp_count + 1)))?;
 
-        let ptr = StorageTxMut::read(sb, tmp_ptr)?.unwrap_or_else(|| panic!("Ptr not found"));
+        let ptr = sb.read(tmp_ptr)?.unwrap_or_else(|| panic!("Ptr not found"));
 
         Ok(ptr)
       })
@@ -93,7 +93,7 @@ impl<SB: StorageBackend> Storage<SB> {
       .sb
       .borrow_mut()
       .transaction_mut(Rc::downgrade(&self.sb), |sb| {
-        let tmp_count = StorageTxMut::read(sb, tmp_count_ptr())?.unwrap_or(0);
+        let tmp_count = sb.read(tmp_count_ptr())?.unwrap_or(0);
 
         for i in 0..tmp_count {
           sb.remove_head(tmp_at_ptr(i))?;

storage/src/storage_tx.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, mem::take};
+use std::{cell::RefCell, collections::HashMap, mem::take, rc::Weak};
 
 use rand::thread_rng;
 use serde::{Deserialize, Serialize};
@@ -11,6 +11,19 @@ use crate::{
 pub trait StorageReader<'a, SB: StorageBackend>: Sized {
   fn read_bytes<T>(&self, ptr: StoragePtr<T>) -> Result<Option<Vec<u8>>, StorageError<SB>>;
 
+  fn get_backend(&self) -> Weak<RefCell<SB>>;
+
+  fn get_auto_ptr<SE: StorageEntity<SB>>(
+    &mut self,
+    ptr: StorageEntryPtr,
+  ) -> StorageAutoPtr<SB, SE> {
+    StorageAutoPtr {
+      _marker: std::marker::PhantomData,
+      sb: self.get_backend(),
+      ptr,
+    }
+  }
+
   fn read<T: for<'de> Deserialize<'de>>(
     &mut self,
     ptr: StoragePtr<T>,
@@ -25,9 +38,6 @@ pub trait StorageReader<'a, SB: StorageBackend>: Sized {
       .map_err(StorageError::from)
   }
 
-  fn get_auto_ptr<SE: StorageEntity<SB>>(&mut self, ptr: StorageEntryPtr)
-    -> StorageAutoPtr<SB, SE>;
-
   fn read_or_err<T: for<'de> Deserialize<'de>>(
     &mut self,
     ptr: StoragePtr<T>,
@@ -56,33 +66,15 @@ pub trait StorageReader<'a, SB: StorageBackend>: Sized {
   }
 }
 
-pub trait StorageTxMut<'a, SB: StorageBackend>: Sized {
+pub trait StorageTxMut<'a, SB: StorageBackend>: StorageReader<'a, SB> + Sized {
   fn ref_deltas(&mut self) -> &mut HashMap<(u64, u64, u64), i64>;
   fn cache(&mut self) -> &mut HashMap<RcKey, StorageEntryPtr>;
-  fn read_bytes<T>(&self, ptr: StoragePtr<T>) -> Result<Option<Vec<u8>>, StorageError<SB>>;
   fn write_bytes<T>(
     &mut self,
     ptr: StoragePtr<T>,
     data: Option<Vec<u8>>,
   ) -> Result<(), StorageError<SB>>;
 
-  fn read<T: for<'de> Deserialize<'de>>(
-    &mut self,
-    ptr: StoragePtr<T>,
-  ) -> Result<Option<T>, StorageError<SB>> {
-    let data = match self.read_bytes(ptr)? {
-      Some(data) => data,
-      None => return Ok(None),
-    };
-
-    bincode::deserialize(&data)
-      .map(Some)
-      .map_err(StorageError::from)
-  }
-
-  fn get_auto_ptr<SE: StorageEntity<SB>>(&mut self, ptr: StorageEntryPtr)
-    -> StorageAutoPtr<SB, SE>;
-
   fn read_or_err<T: for<'de> Deserialize<'de>>(
     &mut self,
     ptr: StoragePtr<T>,
@@ -244,16 +236,3 @@ pub trait StorageTxMut<'a, SB: StorageBackend>: Sized {
     Ok(ptr)
   }
 }
-
-impl<'a, SB: StorageBackend, TxMut: StorageTxMut<'a, SB>> StorageReader<'a, SB> for TxMut {
-  fn read_bytes<T>(&self, ptr: StoragePtr<T>) -> Result<Option<Vec<u8>>, StorageError<SB>> {
-    TxMut::read_bytes(self, ptr)
-  }
-
-  fn get_auto_ptr<SE: StorageEntity<SB>>(
-    &mut self,
-    ptr: StorageEntryPtr,
-  ) -> StorageAutoPtr<SB, SE> {
-    TxMut::get_auto_ptr(self, ptr)
-  }
-}