Remove length hint from FixedByteSize trait

vE5li · vE5li · commit c5aec56b9551 · 2024-02-21T20:17:02.000+01:00
diff --git a/procedural/src/byte/fixed_size.rs b/procedural/src/byte/fixed_size.rs
@@ -15,23 +15,21 @@ pub fn derive_fixed_byte_size_struct(data_struct: DataStruct, generics: Generics
         syn::Fields::Unit => panic!("unit types are not supported"),
     };
 
-    let length_hints = fields.into_iter().map(|mut field| {
+    let sizes = fields.into_iter().zip(types.iter()).map(|(mut field, field_type)| {
         get_unique_attribute(&mut field.attrs, "length_hint")
             .map(|attribute| match attribute.meta {
                 syn::Meta::List(list) => list.tokens,
                 syn::Meta::Path(_) | syn::Meta::NameValue(_) => panic!("expected token stream in attribute"),
             })
-            .map(|length_hint| quote!(Some(((#length_hint) as usize))))
-            .unwrap_or(quote!(None))
+            .map(|length_hint| quote!((#length_hint) as usize))
+            .unwrap_or(quote!(<#field_type as crate::loaders::FixedByteSize>::size_in_bytes()))
     });
 
     quote! {
         impl #impl_generics const crate::loaders::FixedByteSize for #name #type_generics #where_clause {
-            fn size_in_bytes(length_hint: Option<usize>) -> usize {
-                assert!(length_hint.is_none());
-
+            fn size_in_bytes() -> usize {
                 let mut total = 0;
-                #(total += <#types as crate::loaders::FixedByteSize>::size_in_bytes(#length_hints);)*
+                #(total += #sizes;)*
                 total
             }
         }
@@ -48,10 +46,8 @@ pub fn derive_fixed_byte_size_enum(generics: Generics, mut attributes: Vec<Attri
 
     quote! {
         impl #impl_generics const crate::loaders::FixedByteSize for #name #type_generics #where_clause {
-            fn size_in_bytes(length_hint: Option<usize>) -> usize {
-                assert!(length_hint.is_none());
-
-                <#numeric_type as crate::loaders::FixedByteSize>::size_in_bytes(None)
+            fn size_in_bytes() -> usize {
+                <#numeric_type as crate::loaders::FixedByteSize>::size_in_bytes()
             }
         }
     }
diff --git a/procedural/src/byte/helper.rs b/procedural/src/byte/helper.rs
@@ -125,7 +125,7 @@ pub fn byte_convertable_helper(data_struct: DataStruct) -> (Vec<TokenStream>, Ve
                     .expect("repeating_remaining is used but no packet_length attribute is set");
 
                 quote!({
-                    let repeat_count = (#packet_length - ((byte_stream.get_offset() - base_offset) as u16) - 2) / (<#field_type as crate::loaders::FixedByteSizeWrapper>::size_in_bytes(None) as u16);
+                    let repeat_count = (#packet_length - ((byte_stream.get_offset() - base_offset) as u16) - 2) / (<#field_type as crate::loaders::FixedByteSizeWrapper>::size_in_bytes() as u16);
                     // TODO: Add check to make sure this allocation is not too big.
                     let mut vector = Vec::with_capacity(repeat_count as usize);
 
diff --git a/src/loaders/archive/native/mod.rs b/src/loaders/archive/native/mod.rs
@@ -33,8 +33,8 @@ pub struct NativeArchive {
 
 const MAGIC_BYTES: &[u8] = b"Master of Magic\0";
 const UNPACKED_SIZE_OF_MAGIC_STRING: usize = MAGIC_BYTES.len();
-const UNPACKED_SIZE_OF_ARCHIVEHEADER: usize = Header::size_in_bytes(None);
-const UNPACKED_SIZE_OF_FILETABLE: usize = AssetTable::size_in_bytes(None);
+const UNPACKED_SIZE_OF_ARCHIVEHEADER: usize = Header::size_in_bytes();
+const UNPACKED_SIZE_OF_FILETABLE: usize = AssetTable::size_in_bytes();
 
 impl Archive for NativeArchive {
     fn from_path(path: &Path) -> Self {
diff --git a/src/loaders/fixed.rs b/src/loaders/fixed.rs
@@ -4,144 +4,118 @@ use cgmath::{Matrix3, Quaternion, Vector2, Vector3, Vector4};
 
 #[const_trait]
 pub trait FixedByteSizeWrapper {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize;
+    fn size_in_bytes() -> usize;
 }
 
 impl<T: ~const FixedByteSize> const FixedByteSizeWrapper for Vec<T> {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize {
-        T::size_in_bytes(length_hint)
+    fn size_in_bytes() -> usize {
+        T::size_in_bytes()
     }
 }
 
 #[const_trait]
 pub trait FixedByteSize {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize;
+    fn size_in_bytes() -> usize;
 }
 
 impl const FixedByteSize for u8 {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize {
-        assert!(length_hint.is_none());
+    fn size_in_bytes() -> usize {
         core::mem::size_of::<Self>()
     }
 }
 
 impl const FixedByteSize for u16 {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize {
-        assert!(length_hint.is_none());
+    fn size_in_bytes() -> usize {
         core::mem::size_of::<Self>()
     }
 }
 
 impl const FixedByteSize for u32 {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize {
-        assert!(length_hint.is_none());
+    fn size_in_bytes() -> usize {
         core::mem::size_of::<Self>()
     }
 }
 
 impl const FixedByteSize for u64 {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize {
-        assert!(length_hint.is_none());
+    fn size_in_bytes() -> usize {
         core::mem::size_of::<Self>()
     }
 }
 
 impl const FixedByteSize for i8 {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize {
-        assert!(length_hint.is_none());
+    fn size_in_bytes() -> usize {
         core::mem::size_of::<Self>()
     }
 }
 
 impl const FixedByteSize for i16 {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize {
-        assert!(length_hint.is_none());
+    fn size_in_bytes() -> usize {
         core::mem::size_of::<Self>()
     }
 }
 
 impl const FixedByteSize for i32 {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize {
-        assert!(length_hint.is_none());
+    fn size_in_bytes() -> usize {
         core::mem::size_of::<Self>()
     }
 }
 
 impl const FixedByteSize for i64 {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize {
-        assert!(length_hint.is_none());
+    fn size_in_bytes() -> usize {
         core::mem::size_of::<Self>()
     }
 }
 
 impl const FixedByteSize for f32 {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize {
-        assert!(length_hint.is_none());
+    fn size_in_bytes() -> usize {
         core::mem::size_of::<Self>()
     }
 }
 
 impl const FixedByteSize for f64 {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize {
-        assert!(length_hint.is_none());
+    fn size_in_bytes() -> usize {
         core::mem::size_of::<Self>()
     }
 }
 
 impl<T: ~const FixedByteSize, const SIZE: usize> const FixedByteSize for [T; SIZE] {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize {
-        assert!(length_hint.is_none());
-        T::size_in_bytes(None) * SIZE
+    fn size_in_bytes() -> usize {
+        T::size_in_bytes() * SIZE
     }
 }
 
 impl<T: ~const FixedByteSize> const FixedByteSize for Vector2<T> {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize {
-        assert!(length_hint.is_none());
-        T::size_in_bytes(None) * 2
+    fn size_in_bytes() -> usize {
+        T::size_in_bytes() * 2
     }
 }
 
 impl<T: ~const FixedByteSize> const FixedByteSize for Vector3<T> {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize {
-        assert!(length_hint.is_none());
-        T::size_in_bytes(None) * 3
+    fn size_in_bytes() -> usize {
+        T::size_in_bytes() * 3
     }
 }
 
 impl<T: ~const FixedByteSize> const FixedByteSize for Vector4<T> {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize {
-        assert!(length_hint.is_none());
-        T::size_in_bytes(None) * 4
+    fn size_in_bytes() -> usize {
+        T::size_in_bytes() * 4
     }
 }
 
 impl<T: ~const FixedByteSize> const FixedByteSize for Quaternion<T> {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize {
-        assert!(length_hint.is_none());
-        T::size_in_bytes(None) * 4
+    fn size_in_bytes() -> usize {
+        T::size_in_bytes() * 4
     }
 }
 
 impl<T: ~const FixedByteSize> const FixedByteSize for Matrix3<T> {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize {
-        assert!(length_hint.is_none());
-        T::size_in_bytes(None) * 9
+    fn size_in_bytes() -> usize {
+        T::size_in_bytes() * 9
     }
 }
 
 impl const FixedByteSize for Ipv4Addr {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize {
-        assert!(length_hint.is_none());
+    fn size_in_bytes() -> usize {
         4
     }
 }
-
-impl const FixedByteSize for String {
-    fn size_in_bytes(length_hint: Option<usize>) -> usize {
-        match length_hint {
-            Some(length) => length,
-            None => panic!("fixed size string needs to have a length hint"),
-        }
-    }
-}

Original file line number	Diff line number	Diff line change
`@@ -4,144 +4,118 @@ use cgmath::{Matrix3, Quaternion, Vector2, Vector3, Vector4};`
`4`	`4`
`5`	`5`	`#[const_trait]`
`6`	`6`	`pub trait FixedByteSizeWrapper {`
`7`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize;`
	`7`	`+ fn size_in_bytes() -> usize;`
`8`	`8`	`}`
`9`	`9`
`10`	`10`	`impl<T: ~const FixedByteSize> const FixedByteSizeWrapper for Vec<T> {`
`11`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize {`
`12`		`- T::size_in_bytes(length_hint)`
	`11`	`+ fn size_in_bytes() -> usize {`
	`12`	`+ T::size_in_bytes()`
`13`	`13`	`}`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`#[const_trait]`
`17`	`17`	`pub trait FixedByteSize {`
`18`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize;`
	`18`	`+ fn size_in_bytes() -> usize;`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`impl const FixedByteSize for u8 {`
`22`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize {`
`23`		`- assert!(length_hint.is_none());`
	`22`	`+ fn size_in_bytes() -> usize {`
`24`	`23`	`core::mem::size_of::<Self>()`
`25`	`24`	`}`
`26`	`25`	`}`
`27`	`26`
`28`	`27`	`impl const FixedByteSize for u16 {`
`29`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize {`
`30`		`- assert!(length_hint.is_none());`
	`28`	`+ fn size_in_bytes() -> usize {`
`31`	`29`	`core::mem::size_of::<Self>()`
`32`	`30`	`}`
`33`	`31`	`}`
`34`	`32`
`35`	`33`	`impl const FixedByteSize for u32 {`
`36`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize {`
`37`		`- assert!(length_hint.is_none());`
	`34`	`+ fn size_in_bytes() -> usize {`
`38`	`35`	`core::mem::size_of::<Self>()`
`39`	`36`	`}`
`40`	`37`	`}`
`41`	`38`
`42`	`39`	`impl const FixedByteSize for u64 {`
`43`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize {`
`44`		`- assert!(length_hint.is_none());`
	`40`	`+ fn size_in_bytes() -> usize {`
`45`	`41`	`core::mem::size_of::<Self>()`
`46`	`42`	`}`
`47`	`43`	`}`
`48`	`44`
`49`	`45`	`impl const FixedByteSize for i8 {`
`50`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize {`
`51`		`- assert!(length_hint.is_none());`
	`46`	`+ fn size_in_bytes() -> usize {`
`52`	`47`	`core::mem::size_of::<Self>()`
`53`	`48`	`}`
`54`	`49`	`}`
`55`	`50`
`56`	`51`	`impl const FixedByteSize for i16 {`
`57`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize {`
`58`		`- assert!(length_hint.is_none());`
	`52`	`+ fn size_in_bytes() -> usize {`
`59`	`53`	`core::mem::size_of::<Self>()`
`60`	`54`	`}`
`61`	`55`	`}`
`62`	`56`
`63`	`57`	`impl const FixedByteSize for i32 {`
`64`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize {`
`65`		`- assert!(length_hint.is_none());`
	`58`	`+ fn size_in_bytes() -> usize {`
`66`	`59`	`core::mem::size_of::<Self>()`
`67`	`60`	`}`
`68`	`61`	`}`
`69`	`62`
`70`	`63`	`impl const FixedByteSize for i64 {`
`71`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize {`
`72`		`- assert!(length_hint.is_none());`
	`64`	`+ fn size_in_bytes() -> usize {`
`73`	`65`	`core::mem::size_of::<Self>()`
`74`	`66`	`}`
`75`	`67`	`}`
`76`	`68`
`77`	`69`	`impl const FixedByteSize for f32 {`
`78`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize {`
`79`		`- assert!(length_hint.is_none());`
	`70`	`+ fn size_in_bytes() -> usize {`
`80`	`71`	`core::mem::size_of::<Self>()`
`81`	`72`	`}`
`82`	`73`	`}`
`83`	`74`
`84`	`75`	`impl const FixedByteSize for f64 {`
`85`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize {`
`86`		`- assert!(length_hint.is_none());`
	`76`	`+ fn size_in_bytes() -> usize {`
`87`	`77`	`core::mem::size_of::<Self>()`
`88`	`78`	`}`
`89`	`79`	`}`
`90`	`80`
`91`	`81`	`impl<T: ~const FixedByteSize, const SIZE: usize> const FixedByteSize for [T; SIZE] {`
`92`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize {`
`93`		`- assert!(length_hint.is_none());`
`94`		`- T::size_in_bytes(None) * SIZE`
	`82`	`+ fn size_in_bytes() -> usize {`
	`83`	`+ T::size_in_bytes() * SIZE`
`95`	`84`	`}`
`96`	`85`	`}`
`97`	`86`
`98`	`87`	`impl<T: ~const FixedByteSize> const FixedByteSize for Vector2<T> {`
`99`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize {`
`100`		`- assert!(length_hint.is_none());`
`101`		`- T::size_in_bytes(None) * 2`
	`88`	`+ fn size_in_bytes() -> usize {`
	`89`	`+ T::size_in_bytes() * 2`
`102`	`90`	`}`
`103`	`91`	`}`
`104`	`92`
`105`	`93`	`impl<T: ~const FixedByteSize> const FixedByteSize for Vector3<T> {`
`106`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize {`
`107`		`- assert!(length_hint.is_none());`
`108`		`- T::size_in_bytes(None) * 3`
	`94`	`+ fn size_in_bytes() -> usize {`
	`95`	`+ T::size_in_bytes() * 3`
`109`	`96`	`}`
`110`	`97`	`}`
`111`	`98`
`112`	`99`	`impl<T: ~const FixedByteSize> const FixedByteSize for Vector4<T> {`
`113`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize {`
`114`		`- assert!(length_hint.is_none());`
`115`		`- T::size_in_bytes(None) * 4`
	`100`	`+ fn size_in_bytes() -> usize {`
	`101`	`+ T::size_in_bytes() * 4`
`116`	`102`	`}`
`117`	`103`	`}`
`118`	`104`
`119`	`105`	`impl<T: ~const FixedByteSize> const FixedByteSize for Quaternion<T> {`
`120`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize {`
`121`		`- assert!(length_hint.is_none());`
`122`		`- T::size_in_bytes(None) * 4`
	`106`	`+ fn size_in_bytes() -> usize {`
	`107`	`+ T::size_in_bytes() * 4`
`123`	`108`	`}`
`124`	`109`	`}`
`125`	`110`
`126`	`111`	`impl<T: ~const FixedByteSize> const FixedByteSize for Matrix3<T> {`
`127`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize {`
`128`		`- assert!(length_hint.is_none());`
`129`		`- T::size_in_bytes(None) * 9`
	`112`	`+ fn size_in_bytes() -> usize {`
	`113`	`+ T::size_in_bytes() * 9`
`130`	`114`	`}`
`131`	`115`	`}`
`132`	`116`
`133`	`117`	`impl const FixedByteSize for Ipv4Addr {`
`134`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize {`
`135`		`- assert!(length_hint.is_none());`
	`118`	`+ fn size_in_bytes() -> usize {`
`136`	`119`	`4`
`137`	`120`	`}`
`138`	`121`	`}`
`139`		`-`
`140`		`-impl const FixedByteSize for String {`
`141`		`- fn size_in_bytes(length_hint: Option<usize>) -> usize {`
`142`		`- match length_hint {`
`143`		`- Some(length) => length,`
`144`		`- None => panic!("fixed size string needs to have a length hint"),`
`145`		`- }`
`146`		`- }`
`147`		`-}`