feat!: remove BinProperty & name_hash duplication

replaces BinProperty with trait methods on ReaderExt/WriterExt

Author: alanpq

crates/ltk_meta/src/lib.rs

@@ -27,13 +27,13 @@ for (path_hash, object) in &tree.objects {
 
 ```
 use ltk_meta::{Bin, BinObject};
-use ltk_meta::property::values;
+use ltk_meta::property::{values, NoMeta};
 
 // Using the builder pattern
 let tree = Bin::builder()
     .dependency("common.bin")
     .object(
-        BinObject::builder(0x12345678, 0xABCDEF00)
+        BinObject::<NoMeta>::builder(0x12345678, 0xABCDEF00)
             .property(0x1111, values::I32::new(42))
             .property(0x2222, values::String::from("hello"))
             .build()
@@ -70,7 +70,7 @@ tree.to_writer(&mut output)?;
 ```
 */
 pub mod property;
-pub use property::{BinProperty, Kind as PropertyKind, PropertyValueEnum};
+pub use property::{Kind as PropertyKind, PropertyValueEnum};
 
 mod tree;
 pub use tree::*;

crates/ltk_meta/src/property.rs

@@ -6,69 +6,8 @@ pub use kind::*;
 mod r#enum;
 pub use r#enum::*;
 
-use super::traits::{ReaderExt as _, WriterExt as _};
 use super::Error;
-use byteorder::{ReadBytesExt as _, WriteBytesExt as _, LE};
-use std::io;
-
-use crate::traits::PropertyExt;
 
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Clone, Copy, Default, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct NoMeta;
-
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(bound = "for <'dee> M: serde::Serialize + serde::Deserialize<'dee>")
-)]
-#[derive(Clone, PartialEq, Debug)]
-pub struct BinProperty<M = NoMeta> {
-    pub name_hash: u32,
-    #[cfg_attr(feature = "serde", serde(flatten))]
-    pub value: PropertyValueEnum<M>,
-}
-
-impl<M> BinProperty<M> {
-    #[inline(always)]
-    #[must_use]
-    pub fn no_meta(self) -> BinProperty<NoMeta> {
-        BinProperty {
-            name_hash: self.name_hash,
-            value: self.value.no_meta(),
-        }
-    }
-
-    /// Read a BinProperty from a reader. This will read the name_hash, prop kind and then value, in that order.
-    pub fn from_reader<R: io::Read + std::io::Seek + ?Sized>(
-        reader: &mut R,
-        legacy: bool,
-    ) -> Result<Self, Error>
-    where
-        M: Default,
-    {
-        let name_hash = reader.read_u32::<LE>()?;
-        let kind = reader.read_property_kind(legacy)?;
-
-        Ok(Self {
-            name_hash,
-            value: PropertyValueEnum::from_reader(reader, kind, legacy)?,
-        })
-    }
-    pub fn to_writer<W: io::Write + std::io::Seek + ?Sized>(
-        &self,
-        writer: &mut W,
-    ) -> Result<(), io::Error>
-    where
-        M: Clone,
-    {
-        writer.write_u32::<LE>(self.name_hash)?;
-        writer.write_property_kind(self.value.kind())?;
-
-        self.value.to_writer(writer)?;
-        Ok(())
-    }
-    pub fn size(&self) -> usize {
-        5 + self.value.size_no_header()
-    }
-}

crates/ltk_meta/src/property/values/struct.rs

@@ -2,8 +2,10 @@ use std::io;
 
 use crate::{
     property::{Kind, NoMeta},
-    traits::{PropertyExt, PropertyValueExt, ReadProperty, WriteProperty},
-    BinProperty, Error,
+    traits::{
+        PropertyExt, PropertyValueExt, ReadProperty, ReaderExt, WriteProperty, WriterExt as _,
+    },
+    Error, PropertyValueEnum,
 };
 use byteorder::{ReadBytesExt as _, WriteBytesExt as _, LE};
 use indexmap::IndexMap;
@@ -17,7 +19,7 @@ use ltk_io_ext::{measure, window_at};
 #[derive(Clone, PartialEq, Debug, Default)]
 pub struct Struct<M = NoMeta> {
     pub class_hash: u32,
-    pub properties: IndexMap<u32, BinProperty<M>>,
+    pub properties: IndexMap<u32, PropertyValueEnum<M>>,
     pub meta: M,
 }
 
@@ -45,7 +47,13 @@ impl<M> PropertyExt for Struct<M> {
     fn size_no_header(&self) -> usize {
         match self.class_hash {
             0 => 4,
-            _ => 10 + self.properties.values().map(|p| p.size()).sum::<usize>(),
+            _ => {
+                10 + self
+                    .properties
+                    .values()
+                    .map(|p| 5 + p.size_no_header())
+                    .sum::<usize>()
+            }
         }
     }
 
@@ -77,8 +85,8 @@ impl<M: Default> ReadProperty for Struct<M> {
             let prop_count = reader.read_u16::<LE>()?;
             let mut properties = IndexMap::with_capacity(prop_count as _);
             for _ in 0..prop_count {
-                let prop = BinProperty::from_reader(reader, legacy)?;
-                properties.insert(prop.name_hash, prop);
+                let (name_hash, value) = reader.read_property::<M>(legacy)?;
+                properties.insert(name_hash, value);
             }
             Ok::<_, Error>(Self {
                 class_hash,
@@ -116,8 +124,10 @@ impl<M: Clone> WriteProperty for Struct<M> {
         let (size, _) = measure(writer, |writer| {
             writer.write_u16::<LE>(self.properties.len() as _)?;
 
-            for prop in self.properties.values() {
-                prop.to_writer(writer)?;
+            for (name_hash, value) in self.properties.iter() {
+                writer.write_u32::<LE>(*name_hash)?;
+                writer.write_property_kind(value.kind())?;
+                value.to_writer(writer)?;
             }
 
             Ok::<_, io::Error>(())

crates/ltk_meta/src/traits.rs

@@ -1,7 +1,9 @@
 use std::io;
 
+use crate::PropertyValueEnum;
+
 use super::property::Kind;
-use byteorder::{ReadBytesExt, WriteBytesExt};
+use byteorder::{ReadBytesExt, WriteBytesExt, LE};
 
 const HEADER_SIZE: usize = 5;
 
@@ -50,6 +52,22 @@ pub trait ReaderExt: io::Read {
     fn read_property_kind(&mut self, legacy: bool) -> Result<Kind, crate::Error> {
         Kind::unpack(self.read_u8()?, legacy)
     }
+
+    fn read_property<M: Default>(
+        &mut self,
+        legacy: bool,
+    ) -> Result<(u32, PropertyValueEnum<M>), crate::Error>
+    where
+        Self: io::Seek,
+    {
+        let name_hash = self.read_u32::<LE>()?;
+        let kind = self.read_property_kind(legacy)?;
+
+        Ok((
+            name_hash,
+            PropertyValueEnum::from_reader(self, kind, legacy)?,
+        ))
+    }
 }
 
 impl<R: io::Read + ?Sized> ReaderExt for R {}
@@ -68,6 +86,21 @@ pub trait WriterExt: io::Write {
     fn write_property_kind(&mut self, kind: Kind) -> Result<(), io::Error> {
         self.write_u8(kind.into())
     }
+
+    fn write_property<M>(
+        &mut self,
+        name_hash: u32,
+        value: &PropertyValueEnum<M>,
+    ) -> Result<(), io::Error>
+    where
+        M: Clone,
+        Self: io::Seek,
+    {
+        self.write_u32::<LE>(name_hash)?;
+        self.write_property_kind(value.kind())?;
+        value.to_writer(self)?;
+        Ok(())
+    }
 }
 
 impl<R: io::Write + ?Sized> WriterExt for R {}