Fix for uuid

Cargo.toml

@@ -3,15 +3,15 @@ members = ["codegen", "tools/create-data-file", "tools/dump-data-file"]
 
 [package]
 name = "data_bucket"
-version = "0.2.5"
+version = "0.2.6"
 edition = "2021"
 authors = ["Handy-caT"]
 license = "MIT"
 repository = "https://github.com/pathscale/DataBucket"
 description = "DataBucket is container for WorkTable's data"
 
 [dependencies]
-data_bucket_derive = { path = "codegen", version = "0.2.4" }
+data_bucket_derive = { path = "codegen", version = "0.2.6" }
 
 eyre = "0.6.12"
 derive_more = { version = "1.0.0", features = ["from", "error", "display", "into"] }

codegen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "data_bucket_derive"
-version = "0.2.4"
+version = "0.2.6"
 edition = "2021"
 authors = ["Handy-caT"]
 license = "MIT"

codegen/src/persistable/generator/obj_impl.rs

@@ -222,7 +222,7 @@ impl Generator {
             }
         } else {
             quote! {
-                 length * align8(<#inner_ty as Default>::default().aligned_size()) + 8
+                 length * Self::#value_fn_ident() + 8
             }
         };
         let len_value = if is_primitive(&inner_ty_str) {
@@ -231,7 +231,11 @@ impl Generator {
             }
         } else {
             quote! {
-                align8(<#inner_ty as Default>::default().aligned_size())
+                if <#inner_ty as SizeMeasurable>::align() == Some(8) {
+                    align8(<#inner_ty as Default>::default().aligned_size())
+                } else {
+                    <#inner_ty as Default>::default().aligned_size()
+                }
             }
         };
         quote! {

codegen/src/persistable/generator/persistable_impl.rs

@@ -1,6 +1,6 @@
 use crate::persistable::generator::Generator;
 
-use proc_macro2::{Ident, TokenStream};
+use proc_macro2::{Ident, Span, TokenStream};
 use quote::{quote, ToTokens};
 use syn::spanned::Spanned;
 use syn::{Field, GenericParam, Type};
@@ -268,13 +268,15 @@ impl Generator {
             });
             val.unwrap().1.ident.as_ref().unwrap()
         };
+        let value_fn_ident =
+            Ident::new(format!("{}_value_size", ident).as_str(), Span::call_site());
         let len = if is_primitive(&inner_ty_str) {
             quote! {
                 let values_len = align(#size_ident as usize * <#inner_ty as Default>::default().aligned_size()) + 8;
             }
         } else {
             quote! {
-                let values_len = #size_ident as usize * align8(<#inner_ty as Default>::default().aligned_size()) + 8;
+                let values_len = #size_ident as usize * Self::#value_fn_ident() + 8;
             }
         };
         quote! {

src/page/index/page.rs

@@ -301,6 +301,7 @@ impl<T: Default + SizeMeasurable> IndexPage<T> {
 mod tests {
     use crate::page::IndexValue;
     use crate::{get_index_page_size_from_data_length, IndexPage, Persistable, INNER_PAGE_SIZE};
+    use uuid::Uuid;
 
     #[test]
     fn test_bytes() {
@@ -322,6 +323,47 @@ mod tests {
         assert_eq!(new_page.index_values, page.index_values);
     }
 
+    #[test]
+    fn test_bytes_128() {
+        let size: usize = get_index_page_size_from_data_length::<u128>(INNER_PAGE_SIZE);
+        println!("size: {}", size);
+        let page = IndexPage::<u128>::new(
+            IndexValue {
+                key: u128::default(),
+                link: Default::default(),
+            },
+            size,
+        );
+        let bytes = page.as_bytes();
+        let new_page = IndexPage::<u128>::from_bytes(bytes.as_ref());
+
+        assert_eq!(new_page.node_id, page.node_id);
+        assert_eq!(new_page.current_index, page.current_index);
+        assert_eq!(new_page.size, page.size);
+        assert_eq!(new_page.slots, page.slots);
+        assert_eq!(new_page.index_values, page.index_values);
+    }
+
+    #[test]
+    fn test_bytes_uuid() {
+        let size: usize = get_index_page_size_from_data_length::<Uuid>(INNER_PAGE_SIZE);
+        let page = IndexPage::<Uuid>::new(
+            IndexValue {
+                key: Uuid::new_v4(),
+                link: Default::default(),
+            },
+            size,
+        );
+        let bytes = page.as_bytes();
+        let new_page = IndexPage::<Uuid>::from_bytes(bytes.as_ref());
+
+        assert_eq!(new_page.node_id, page.node_id);
+        assert_eq!(new_page.current_index, page.current_index);
+        assert_eq!(new_page.size, page.size);
+        assert_eq!(new_page.slots, page.slots);
+        assert_eq!(new_page.index_values, page.index_values);
+    }
+
     #[test]
     fn test_split() {
         let mut page = IndexPage::<u64>::new(

src/util/sized.rs

@@ -146,8 +146,14 @@ where
             2
         } else if val_size == 4 {
             4
+        } else if let Some(al) = T::align() {
+            if al % 8 == 0 {
+                align8(val_size)
+            } else {
+                val_size
+            }
         } else {
-            align8(val_size)
+            val_size
         };
 
         align(self.len() * vec_content_size) + 8
@@ -233,6 +239,48 @@ mod test {
     use crate::util::sized::SizeMeasurable;
     use crate::{IndexValue, Link};
     use rkyv::to_bytes;
+    use uuid::Uuid;
+
+    #[test]
+    fn test_uuid() {
+        let u = Uuid::new_v4();
+        assert_eq!(
+            u.aligned_size(),
+            rkyv::to_bytes::<rkyv::rancor::Error>(&u).unwrap().len()
+        );
+        let t = (Uuid::new_v4(), Link::default());
+        assert_eq!(
+            t.aligned_size(),
+            rkyv::to_bytes::<rkyv::rancor::Error>(&t).unwrap().len()
+        );
+        let v = IndexValue {
+            key: u,
+            link: Default::default(),
+        };
+        assert_eq!(
+            v.aligned_size(),
+            rkyv::to_bytes::<rkyv::rancor::Error>(&v).unwrap().len()
+        );
+        let mut vec = Vec::new();
+        vec.push(IndexValue {
+            key: Uuid::new_v4(),
+            link: Default::default(),
+        });
+        assert_eq!(
+            vec.aligned_size(),
+            rkyv::to_bytes::<rkyv::rancor::Error>(&vec).unwrap().len()
+        );
+        for _ in 0..600 {
+            vec.push(IndexValue {
+                key: Uuid::new_v4(),
+                link: Default::default(),
+            })
+        }
+        assert_eq!(
+            vec.aligned_size(),
+            rkyv::to_bytes::<rkyv::rancor::Error>(&vec).unwrap().len()
+        )
+    }
 
     #[test]
     fn test_tuple() {