Toc corrections

Cargo.toml

@@ -3,7 +3,7 @@ members = ["codegen", "tools/create-data-file", "tools/dump-data-file"]
 
 [package]
 name = "data_bucket"
-version = "0.2.4"
+version = "0.2.5"
 edition = "2021"
 authors = ["Handy-caT"]
 license = "MIT"

src/page/index/table_of_contents_page.rs

@@ -1,12 +1,11 @@
-use std::collections::BTreeMap;
-
-use data_bucket_codegen::Persistable;
 use rkyv::{Archive, Deserialize, Serialize};
+use std::collections::BTreeMap;
+use std::fmt::Debug;
 
 use crate::page::PageId;
 use crate::{align, Persistable, SizeMeasurable};
 
-#[derive(Archive, Clone, Deserialize, Debug, Serialize, Persistable)]
+#[derive(Archive, Clone, Deserialize, Debug, Serialize)]
 pub struct TableOfContentsPage<T: Ord + Eq> {
     records: BTreeMap<T, PageId>,
 
@@ -22,25 +21,76 @@ where
         Self {
             records: BTreeMap::new(),
             empty_pages: vec![],
-            estimated_size: usize::default().aligned_size()
-                + Option::<PageId>::default().aligned_size(),
+            estimated_size: usize::default().aligned_size() + 12,
+        }
+    }
+}
+
+#[derive(Archive, Clone, Deserialize, Debug, Serialize)]
+struct TableOfContentsPagePersisted<T: Ord + Eq> {
+    records: Vec<(T, PageId)>,
+    empty_pages: Vec<PageId>,
+    estimated_size: usize,
+}
+
+impl<T: Ord + Eq> Persistable for TableOfContentsPage<T>
+where
+    T: Clone
+        + rkyv::Archive
+        + for<'a> rkyv::Serialize<
+            rkyv::rancor::Strategy<
+                rkyv::ser::Serializer<
+                    rkyv::util::AlignedVec,
+                    rkyv::ser::allocator::ArenaHandle<'a>,
+                    rkyv::ser::sharing::Share,
+                >,
+                rkyv::rancor::Error,
+            >,
+        >,
+    <T as rkyv::Archive>::Archived:
+        rkyv::Deserialize<T, rkyv::api::high::HighDeserializer<rkyv::rancor::Error>> + Ord,
+{
+    fn as_bytes(&self) -> impl AsRef<[u8]> {
+        let records = self
+            .records
+            .iter()
+            .map(|(k, v)| (k.clone(), *v))
+            .collect::<Vec<_>>();
+        let model = TableOfContentsPagePersisted {
+            records,
+            empty_pages: self.empty_pages.clone(),
+            estimated_size: self.estimated_size,
+        };
+        rkyv::to_bytes::<rkyv::rancor::Error>(&model).unwrap()
+    }
+    fn from_bytes(bytes: &[u8]) -> Self {
+        let archived = unsafe {
+            rkyv::access_unchecked::<<TableOfContentsPagePersisted<T> as Archive>::Archived>(bytes)
+        };
+        let model: TableOfContentsPagePersisted<T> =
+            rkyv::deserialize::<_, rkyv::rancor::Error>(archived).expect("data should be valid");
+        let records = BTreeMap::from_iter(model.records);
+        Self {
+            records,
+            estimated_size: model.estimated_size,
+            empty_pages: model.empty_pages,
         }
     }
 }
 
 impl<T> TableOfContentsPage<T>
 where
-    T: Ord + Eq,
+    T: Debug + Ord + Eq,
 {
     pub fn estimated_size(&self) -> usize {
         self.estimated_size
     }
 
     pub fn insert(&mut self, val: T, page_id: PageId)
     where
-        T: SizeMeasurable,
+        T: SizeMeasurable + Clone,
     {
-        self.estimated_size += align(val.aligned_size() + page_id.0.aligned_size());
+        self.estimated_size += (val.clone(), page_id).aligned_size();
         let _ = self.records.insert(val, page_id);
     }
 
@@ -85,12 +135,12 @@ where
             .expect("value should be available if remove is called")
     }
 
-    pub fn update_key(&mut self, old_key: &T, new_key: T) {
-        let id = self
-            .records
-            .remove(old_key)
-            .expect("value should be available if update is called");
-        self.records.insert(new_key, id);
+    pub fn update_key(&mut self, old_key: &T, new_key: T) -> Option<()> {
+        if let Some(id) = self.records.remove(old_key) {
+            self.records.insert(new_key, id);
+            return Some(());
+        }
+        None
     }
 
     pub fn contains(&self, val: &T) -> bool {
@@ -113,3 +163,26 @@ where
         self.records.into_iter()
     }
 }
+
+#[cfg(test)]
+mod test {
+    use crate::{Link, Persistable, TableOfContentsPage};
+
+    #[test]
+    fn test_sizes() {
+        let mut toc_page = TableOfContentsPage::<(u64, Link)>::default();
+        assert_eq!(toc_page.as_bytes().as_ref().len(), toc_page.estimated_size);
+        toc_page.insert(
+            (
+                128,
+                Link {
+                    page_id: 1.into(),
+                    offset: 40,
+                    length: 80,
+                },
+            ),
+            6.into(),
+        );
+        assert_eq!(toc_page.as_bytes().as_ref().len(), toc_page.estimated_size);
+    }
+}

src/util/sized.rs

@@ -97,8 +97,32 @@ where
     T2: SizeMeasurable,
 {
     fn aligned_size(&self) -> usize {
+        if let Some(align) = T1::align() {
+            if align % 8 == 0 {
+                return align8(self.0.aligned_size() + self.1.aligned_size());
+            }
+        }
+        if let Some(align) = T2::align() {
+            if align % 8 == 0 {
+                return align8(self.0.aligned_size() + self.1.aligned_size());
+            }
+        }
         align(self.0.aligned_size() + self.1.aligned_size())
     }
+
+    fn align() -> Option<usize> {
+        if let Some(align) = T1::align() {
+            if align % 8 == 0 {
+                return Some(8);
+            }
+        }
+        if let Some(align) = T2::align() {
+            if align % 8 == 0 {
+                return Some(8);
+            }
+        }
+        None
+    }
 }
 
 // That was found on practice... Check unit test for proofs that works.
@@ -207,7 +231,27 @@ where
 #[cfg(test)]
 mod test {
     use crate::util::sized::SizeMeasurable;
-    use crate::IndexValue;
+    use crate::{IndexValue, Link};
+    use rkyv::to_bytes;
+
+    #[test]
+    fn test_tuple() {
+        let t = (u64::MAX, Link::default());
+        assert_eq!(
+            t.aligned_size(),
+            to_bytes::<rkyv::rancor::Error>(&t).unwrap().len()
+        );
+        let t = (u32::MAX, Link::default());
+        assert_eq!(
+            t.aligned_size(),
+            to_bytes::<rkyv::rancor::Error>(&t).unwrap().len()
+        );
+        let t = (u8::MAX, Link::default());
+        assert_eq!(
+            t.aligned_size(),
+            to_bytes::<rkyv::rancor::Error>(&t).unwrap().len()
+        )
+    }
 
     #[test]
     fn test_string() {