Filly mirror the new Encodable API

robertwayne · robertwayne · commit d8343dd637c1 · 2025-05-17T17:11:01.000-04:00
diff --git a/rust/bufferfish-core/src/decodable.rs b/rust/bufferfish-core/src/decodable.rs
@@ -5,7 +5,16 @@ use crate::{Bufferfish, BufferfishError};
 /// Types implementing this trait are able to be decoded from a `Bufferfish`.
 pub trait Decodable: Sized {
     /// Decode the type from a given `Bufferfish`.
-    fn decode(bf: &mut Bufferfish) -> Result<Self, BufferfishError>;
+    fn decode(bf: &mut Bufferfish) -> Result<Self, BufferfishError> {
+        Self::decode_value(bf)
+    }
+
+    /// Decodes a raw value from a given `Bufferfish`.
+    ///
+    /// Note: This is generally not what you want to call on types
+    /// implementing `Decodable`, as it will not decode the header value.
+    /// Instead, use `decode` to decode an entire type.
+    fn decode_value(bf: &mut Bufferfish) -> Result<Self, BufferfishError>;
 
     /// Creates a checked, generic type from a `Bufferfish`.
     ///
@@ -47,7 +56,7 @@ pub trait Decodable: Sized {
 }
 
 impl Decodable for u8 {
-    fn decode(bf: &mut Bufferfish) -> Result<u8, BufferfishError> {
+    fn decode_value(bf: &mut Bufferfish) -> Result<u8, BufferfishError> {
         bf.read_u8()
     }
 
@@ -61,7 +70,7 @@ impl Decodable for u8 {
 }
 
 impl Decodable for u16 {
-    fn decode(bf: &mut Bufferfish) -> Result<u16, BufferfishError> {
+    fn decode_value(bf: &mut Bufferfish) -> Result<u16, BufferfishError> {
         bf.read_u16()
     }
 
@@ -75,7 +84,7 @@ impl Decodable for u16 {
 }
 
 impl Decodable for u32 {
-    fn decode(bf: &mut Bufferfish) -> Result<u32, BufferfishError> {
+    fn decode_value(bf: &mut Bufferfish) -> Result<u32, BufferfishError> {
         bf.read_u32()
     }
 
@@ -89,7 +98,7 @@ impl Decodable for u32 {
 }
 
 impl Decodable for u64 {
-    fn decode(bf: &mut Bufferfish) -> Result<u64, BufferfishError> {
+    fn decode_value(bf: &mut Bufferfish) -> Result<u64, BufferfishError> {
         bf.read_u64()
     }
 
@@ -103,7 +112,7 @@ impl Decodable for u64 {
 }
 
 impl Decodable for u128 {
-    fn decode(bf: &mut Bufferfish) -> Result<u128, BufferfishError> {
+    fn decode_value(bf: &mut Bufferfish) -> Result<u128, BufferfishError> {
         bf.read_u128()
     }
 
@@ -117,7 +126,7 @@ impl Decodable for u128 {
 }
 
 impl Decodable for i8 {
-    fn decode(bf: &mut Bufferfish) -> Result<i8, BufferfishError> {
+    fn decode_value(bf: &mut Bufferfish) -> Result<i8, BufferfishError> {
         bf.read_i8()
     }
 
@@ -131,7 +140,7 @@ impl Decodable for i8 {
 }
 
 impl Decodable for i16 {
-    fn decode(bf: &mut Bufferfish) -> Result<i16, BufferfishError> {
+    fn decode_value(bf: &mut Bufferfish) -> Result<i16, BufferfishError> {
         bf.read_i16()
     }
 
@@ -145,7 +154,7 @@ impl Decodable for i16 {
 }
 
 impl Decodable for i32 {
-    fn decode(bf: &mut Bufferfish) -> Result<i32, BufferfishError> {
+    fn decode_value(bf: &mut Bufferfish) -> Result<i32, BufferfishError> {
         bf.read_i32()
     }
 
@@ -159,7 +168,7 @@ impl Decodable for i32 {
 }
 
 impl Decodable for i64 {
-    fn decode(bf: &mut Bufferfish) -> Result<i64, BufferfishError> {
+    fn decode_value(bf: &mut Bufferfish) -> Result<i64, BufferfishError> {
         bf.read_i64()
     }
 
@@ -173,7 +182,7 @@ impl Decodable for i64 {
 }
 
 impl Decodable for i128 {
-    fn decode(bf: &mut Bufferfish) -> Result<i128, BufferfishError> {
+    fn decode_value(bf: &mut Bufferfish) -> Result<i128, BufferfishError> {
         bf.read_i128()
     }
 
@@ -187,7 +196,7 @@ impl Decodable for i128 {
 }
 
 impl Decodable for bool {
-    fn decode(bf: &mut Bufferfish) -> Result<bool, BufferfishError> {
+    fn decode_value(bf: &mut Bufferfish) -> Result<bool, BufferfishError> {
         bf.read_bool()
     }
 
@@ -201,7 +210,7 @@ impl Decodable for bool {
 }
 
 impl Decodable for String {
-    fn decode(bf: &mut Bufferfish) -> Result<String, BufferfishError> {
+    fn decode_value(bf: &mut Bufferfish) -> Result<String, BufferfishError> {
         bf.read_string()
     }
 
@@ -215,12 +224,12 @@ impl Decodable for String {
 }
 
 impl<T: Decodable> Decodable for Vec<T> {
-    fn decode(bf: &mut Bufferfish) -> Result<Vec<T>, BufferfishError> {
+    fn decode_value(bf: &mut Bufferfish) -> Result<Vec<T>, BufferfishError> {
         let len = bf.read_u16()? as usize;
         let mut vec = Vec::with_capacity(len);
 
         for _ in 0..len {
-            vec.push(T::decode(bf)?);
+            vec.push(T::decode_value(bf)?);
         }
 
         Ok(vec)
diff --git a/rust/bufferfish-derive/src/lib.rs b/rust/bufferfish-derive/src/lib.rs
@@ -108,7 +108,7 @@ pub fn bufferfish_impl_decodable(input: proc_macro::TokenStream) -> proc_macro::
                     let ident = field.ident.as_ref().expect("named fields required");
                     let ty = &field.ty;
                     quote! {
-                        #ident: <#ty as bufferfish::Decodable>::decode(bf)?,
+                        #ident: <#ty as bufferfish::Decodable>::decode_value(bf)?,
                     }
                 })
                 .collect::<Vec<_>>(),
@@ -118,7 +118,7 @@ pub fn bufferfish_impl_decodable(input: proc_macro::TokenStream) -> proc_macro::
                 .map(|field| {
                     let ty = &field.ty;
                     quote! {
-                        <#ty as bufferfish::Decodable>::decode(bf)?,
+                        <#ty as bufferfish::Decodable>::decode_value(bf)?,
                     }
                 })
                 .collect::<Vec<_>>(),
@@ -218,6 +218,10 @@ pub fn bufferfish_impl_decodable(input: proc_macro::TokenStream) -> proc_macro::
                     impl bufferfish::Decodable for #name {
                         fn decode(bf: &mut bufferfish::Bufferfish) -> Result<Self, bufferfish::BufferfishError> {
                             #packet_id_snippet
+                            Self::decode_value(bf)
+                        }
+
+                        fn decode_value(bf: &mut bufferfish::Bufferfish) -> Result<Self, bufferfish::BufferfishError> {
                             Ok(Self {
                                 #(#decoded_snippets)*
                             })
@@ -244,6 +248,10 @@ pub fn bufferfish_impl_decodable(input: proc_macro::TokenStream) -> proc_macro::
                     impl bufferfish::Decodable for #name {
                         fn decode(bf: &mut bufferfish::Bufferfish) -> Result<Self, bufferfish::BufferfishError> {
                             #packet_id_snippet
+                            Self::decode_value(bf)
+                        }
+
+                        fn decode_value(bf: &mut bufferfish::Bufferfish) -> Result<Self, bufferfish::BufferfishError> {
                             Ok(Self(
                                 #(#decoded_snippets)*
                             ))
@@ -270,6 +278,10 @@ pub fn bufferfish_impl_decodable(input: proc_macro::TokenStream) -> proc_macro::
                     impl bufferfish::Decodable for #name {
                         fn decode(bf: &mut bufferfish::Bufferfish) -> Result<Self, bufferfish::BufferfishError> {
                             #packet_id_snippet
+                            Self::decode_value(bf)
+                        }
+
+                        fn decode_value(bf: &mut bufferfish::Bufferfish) -> Result<Self, bufferfish::BufferfishError> {
                             Ok(Self)
                         }
 
@@ -291,6 +303,10 @@ pub fn bufferfish_impl_decodable(input: proc_macro::TokenStream) -> proc_macro::
                 impl bufferfish::Decodable for #name {
                     fn decode(bf: &mut bufferfish::Bufferfish) -> Result<Self, bufferfish::BufferfishError> {
                         #packet_id_snippet
+                        Self::decode_value(bf)
+                    }
+
+                    fn decode_value(bf: &mut bufferfish::Bufferfish) -> Result<Self, bufferfish::BufferfishError> {
                         let variant_idx = bf.read_u8()?;
                         Ok(match variant_idx {
                             #(#decoded_snippets)*

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,16 @@ use crate::{Bufferfish, BufferfishError};`
`5`	`5`	/// Types implementing this trait are able to be decoded from a `Bufferfish`.
`6`	`6`	`pub trait Decodable: Sized {`
`7`	`7`	/// Decode the type from a given `Bufferfish`.
`8`		`- fn decode(bf: &mut Bufferfish) -> Result<Self, BufferfishError>;`
	`8`	`+ fn decode(bf: &mut Bufferfish) -> Result<Self, BufferfishError> {`
	`9`	`+ Self::decode_value(bf)`
	`10`	`+ }`
	`11`	`+`
	`12`	+ /// Decodes a raw value from a given `Bufferfish`.
	`13`	`+ ///`
	`14`	`+ /// Note: This is generally not what you want to call on types`
	`15`	+ /// implementing `Decodable`, as it will not decode the header value.
	`16`	+ /// Instead, use `decode` to decode an entire type.
	`17`	`+ fn decode_value(bf: &mut Bufferfish) -> Result<Self, BufferfishError>;`
`9`	`18`
`10`	`19`	/// Creates a checked, generic type from a `Bufferfish`.
`11`	`20`	`///`
`@@ -47,7 +56,7 @@ pub trait Decodable: Sized {`
`47`	`56`	`}`
`48`	`57`
`49`	`58`	`impl Decodable for u8 {`
`50`		`- fn decode(bf: &mut Bufferfish) -> Result<u8, BufferfishError> {`
	`59`	`+ fn decode_value(bf: &mut Bufferfish) -> Result<u8, BufferfishError> {`
`51`	`60`	`bf.read_u8()`
`52`	`61`	`}`
`53`	`62`
`@@ -61,7 +70,7 @@ impl Decodable for u8 {`
`61`	`70`	`}`
`62`	`71`
`63`	`72`	`impl Decodable for u16 {`
`64`		`- fn decode(bf: &mut Bufferfish) -> Result<u16, BufferfishError> {`
	`73`	`+ fn decode_value(bf: &mut Bufferfish) -> Result<u16, BufferfishError> {`
`65`	`74`	`bf.read_u16()`
`66`	`75`	`}`
`67`	`76`
`@@ -75,7 +84,7 @@ impl Decodable for u16 {`
`75`	`84`	`}`
`76`	`85`
`77`	`86`	`impl Decodable for u32 {`
`78`		`- fn decode(bf: &mut Bufferfish) -> Result<u32, BufferfishError> {`
	`87`	`+ fn decode_value(bf: &mut Bufferfish) -> Result<u32, BufferfishError> {`
`79`	`88`	`bf.read_u32()`
`80`	`89`	`}`
`81`	`90`
`@@ -89,7 +98,7 @@ impl Decodable for u32 {`
`89`	`98`	`}`
`90`	`99`
`91`	`100`	`impl Decodable for u64 {`
`92`		`- fn decode(bf: &mut Bufferfish) -> Result<u64, BufferfishError> {`
	`101`	`+ fn decode_value(bf: &mut Bufferfish) -> Result<u64, BufferfishError> {`
`93`	`102`	`bf.read_u64()`
`94`	`103`	`}`
`95`	`104`
`@@ -103,7 +112,7 @@ impl Decodable for u64 {`
`103`	`112`	`}`
`104`	`113`
`105`	`114`	`impl Decodable for u128 {`
`106`		`- fn decode(bf: &mut Bufferfish) -> Result<u128, BufferfishError> {`
	`115`	`+ fn decode_value(bf: &mut Bufferfish) -> Result<u128, BufferfishError> {`
`107`	`116`	`bf.read_u128()`
`108`	`117`	`}`
`109`	`118`
`@@ -117,7 +126,7 @@ impl Decodable for u128 {`
`117`	`126`	`}`
`118`	`127`
`119`	`128`	`impl Decodable for i8 {`
`120`		`- fn decode(bf: &mut Bufferfish) -> Result<i8, BufferfishError> {`
	`129`	`+ fn decode_value(bf: &mut Bufferfish) -> Result<i8, BufferfishError> {`
`121`	`130`	`bf.read_i8()`
`122`	`131`	`}`
`123`	`132`
`@@ -131,7 +140,7 @@ impl Decodable for i8 {`
`131`	`140`	`}`
`132`	`141`
`133`	`142`	`impl Decodable for i16 {`
`134`		`- fn decode(bf: &mut Bufferfish) -> Result<i16, BufferfishError> {`
	`143`	`+ fn decode_value(bf: &mut Bufferfish) -> Result<i16, BufferfishError> {`
`135`	`144`	`bf.read_i16()`
`136`	`145`	`}`
`137`	`146`
`@@ -145,7 +154,7 @@ impl Decodable for i16 {`
`145`	`154`	`}`
`146`	`155`
`147`	`156`	`impl Decodable for i32 {`
`148`		`- fn decode(bf: &mut Bufferfish) -> Result<i32, BufferfishError> {`
	`157`	`+ fn decode_value(bf: &mut Bufferfish) -> Result<i32, BufferfishError> {`
`149`	`158`	`bf.read_i32()`
`150`	`159`	`}`
`151`	`160`
`@@ -159,7 +168,7 @@ impl Decodable for i32 {`
`159`	`168`	`}`
`160`	`169`
`161`	`170`	`impl Decodable for i64 {`
`162`		`- fn decode(bf: &mut Bufferfish) -> Result<i64, BufferfishError> {`
	`171`	`+ fn decode_value(bf: &mut Bufferfish) -> Result<i64, BufferfishError> {`
`163`	`172`	`bf.read_i64()`
`164`	`173`	`}`
`165`	`174`
`@@ -173,7 +182,7 @@ impl Decodable for i64 {`
`173`	`182`	`}`
`174`	`183`
`175`	`184`	`impl Decodable for i128 {`
`176`		`- fn decode(bf: &mut Bufferfish) -> Result<i128, BufferfishError> {`
	`185`	`+ fn decode_value(bf: &mut Bufferfish) -> Result<i128, BufferfishError> {`
`177`	`186`	`bf.read_i128()`
`178`	`187`	`}`
`179`	`188`
`@@ -187,7 +196,7 @@ impl Decodable for i128 {`
`187`	`196`	`}`
`188`	`197`
`189`	`198`	`impl Decodable for bool {`
`190`		`- fn decode(bf: &mut Bufferfish) -> Result<bool, BufferfishError> {`
	`199`	`+ fn decode_value(bf: &mut Bufferfish) -> Result<bool, BufferfishError> {`
`191`	`200`	`bf.read_bool()`
`192`	`201`	`}`
`193`	`202`
`@@ -201,7 +210,7 @@ impl Decodable for bool {`
`201`	`210`	`}`
`202`	`211`
`203`	`212`	`impl Decodable for String {`
`204`		`- fn decode(bf: &mut Bufferfish) -> Result<String, BufferfishError> {`
	`213`	`+ fn decode_value(bf: &mut Bufferfish) -> Result<String, BufferfishError> {`
`205`	`214`	`bf.read_string()`
`206`	`215`	`}`
`207`	`216`
`@@ -215,12 +224,12 @@ impl Decodable for String {`
`215`	`224`	`}`
`216`	`225`
`217`	`226`	`impl<T: Decodable> Decodable for Vec<T> {`
`218`		`- fn decode(bf: &mut Bufferfish) -> Result<Vec<T>, BufferfishError> {`
	`227`	`+ fn decode_value(bf: &mut Bufferfish) -> Result<Vec<T>, BufferfishError> {`
`219`	`228`	`let len = bf.read_u16()? as usize;`
`220`	`229`	`let mut vec = Vec::with_capacity(len);`
`221`	`230`
`222`	`231`	`for _ in 0..len {`
`223`		`- vec.push(T::decode(bf)?);`
	`232`	`+ vec.push(T::decode_value(bf)?);`
`224`	`233`	`}`
`225`	`234`
`226`	`235`	`Ok(vec)`