Cleaup

src/disktree/dptr.rs

@@ -16,7 +16,7 @@ pub(crate) fn read<R>(src: &mut R) -> Result<u64>
 where
     R: Read + Seek,
 {
-    let mut buf = [0_u8; 8];
+    let mut buf = [0u8; size_of::<u64>()];
     src.read_exact(&mut buf[..DPTR_SZ])?;
     let dptr = u64::from_le_bytes(buf);
     Ok(dptr)

src/disktree/iter.rs

@@ -1,30 +1,11 @@
 use crate::{
     cell::CellStack,
-    disktree::{dptr, tree::HDR_SZ},
+    disktree::{dptr, tree::HDR_SZ, Deserializer},
     error::Result,
-    Cell,
 };
 use byteorder::ReadBytesExt;
 use std::io::{Read, Seek, SeekFrom};
 
-pub trait Deserializer<R> {
-    /// This can be the serialized type or a result, depending on
-    /// fallability.
-    type T;
-    fn read(&self, rdr: Result<(Cell, &mut R)>) -> Self::T;
-}
-
-impl<R, T, F> Deserializer<R> for F
-where
-    R: Read,
-    F: Fn(Result<(Cell, &mut R)>) -> T,
-{
-    type T = T;
-    fn read(&self, rdr: Result<(Cell, &mut R)>) -> T {
-        self(rdr)
-    }
-}
-
 pub(crate) struct Iter<'a, R, F> {
     cell_stack: CellStack,
     curr: Option<(u8, u64)>,
@@ -88,13 +69,16 @@ where
     }
 
     fn node_buf(&mut self) -> Vec<(u8, u64)> {
-        let buf = self.recycle_bin.pop().unwrap_or_default();
-        assert!(buf.is_empty());
+        let buf = self
+            .recycle_bin
+            .pop()
+            .unwrap_or_else(|| Vec::with_capacity(7));
+        debug_assert!(buf.is_empty());
         buf
     }
 
     fn recycle_buf(&mut self, buf: Vec<(u8, u64)>) {
-        assert!(buf.is_empty());
+        debug_assert!(buf.is_empty());
         self.recycle_bin.push(buf);
     }
 

src/disktree/mod.rs

@@ -1,10 +1,12 @@
 //! An on-disk hextree.
 
 pub use tree::DiskTree;
+pub use value_read::Deserializer;
 
 mod dptr;
 mod iter;
 mod tree;
+mod value_read;
 mod writer;
 
 #[cfg(test)]
@@ -112,8 +114,14 @@ mod tests {
 
         // Create the iterator with the user-defined deserialzer.
         let disktree_iter = monaco_disktree.iter(deserialze_cell).unwrap();
+        let start = std::time::Instant::now();
         let disktree_collection: Vec<_> = disktree_iter.collect::<Result<Vec<_>, _>>().unwrap();
+        let elapsed = start.elapsed();
+        println!("{elapsed:?}");
+        let start = std::time::Instant::now();
         let hextree_collection: Vec<_> = monaco.iter().map(|(k, v)| (k, *v)).collect();
+        let elapsed = start.elapsed();
+        println!("{elapsed:?}");
 
         assert_eq!(
             hextree_collection,

src/disktree/tree.rs

@@ -2,7 +2,8 @@ use crate::{
     digits::Digits,
     disktree::{
         dptr::{self, DPTR_NULL, DPTR_SZ},
-        iter::{Deserializer, Iter},
+        iter::Iter,
+        Deserializer,
     },
     error::{Error, Result},
     Cell,

src/disktree/value_read.rs

@@ -0,0 +1,33 @@
+use crate::{error::Result, Cell};
+use std::io::Read;
+
+/// The `Deserializer` trait defines the contract for reading concrete types
+/// from a disk tree.
+pub trait Deserializer<R> {
+    /// The associated type `T` represents the result of deserialization,
+    /// which may be the deserialized type or an error result, depending on fallibility.
+    type T;
+
+    /// Reads data from the provided reader and returns the deserialized result.
+    ///
+    /// # Arguments
+    ///
+    /// * `rdr` - A `Result` containing a `Cell` and a mutable reference to the reader.
+    ///
+    /// # Returns
+    ///
+    /// The deserialized result, which can be the deserialized type or an error.
+    fn read(&self, rdr: Result<(Cell, &mut R)>) -> Self::T;
+}
+
+impl<R, T, F> Deserializer<R> for F
+where
+    R: Read,
+    F: Fn(Result<(Cell, &mut R)>) -> T,
+{
+    type T = T;
+
+    fn read(&self, rdr: Result<(Cell, &mut R)>) -> T {
+        self(rdr)
+    }
+}