fix: optional struct and some docs

Author: Crauzer

crates/league-toolkit/src/core/meta/bin_tree/object.rs

@@ -14,6 +14,13 @@ pub struct BinTreeObject {
 }
 
 impl BinTreeObject {
+    /// Reads a BinTreeObject from a reader.
+    ///
+    /// # Arguments
+    ///
+    /// * `reader` - A reader that implements io::Read and io::Seek.
+    /// * `class_hash` - The hash of the class of the object.
+    /// * `legacy` - Whether to read in legacy format.
     pub fn from_reader<R: io::Read + io::Seek + ?Sized>(
         reader: &mut R,
         class_hash: u32,
@@ -43,6 +50,12 @@ impl BinTreeObject {
         Ok(value)
     }
 
+    /// Writes a BinTreeObject to a writer.
+    ///
+    /// # Arguments
+    ///
+    /// * `writer` - A writer that implements io::Write and io::Seek.
+    /// * `legacy` - Whether to write in legacy format.
     pub fn to_writer<W: io::Write + io::Seek + ?Sized>(
         &self,
         writer: &mut W,
@@ -51,6 +64,7 @@ impl BinTreeObject {
         if legacy {
             unimplemented!("legacy BinTreeObject write");
         }
+
         let size_pos = writer.stream_position()?;
         writer.write_u32::<LE>(0)?;
 

crates/league-toolkit/src/core/meta/bin_tree/read.rs

@@ -9,6 +9,12 @@ use io_ext::ReaderExt;
 impl BinTree {
     pub const PROP: u32 = u32::from_le_bytes(*b"PROP");
     pub const PTCH: u32 = u32::from_le_bytes(*b"PTCH");
+
+    /// Reads a BinTree from a reader.
+    ///
+    /// # Arguments
+    ///
+    /// * `reader` - A reader that implements io::Read and io::Seek.
     pub fn from_reader<R: io::Read + std::io::Seek + ?Sized>(
         reader: &mut R,
     ) -> Result<Self, ParseError> {

crates/league-toolkit/src/core/meta/bin_tree/write.rs

@@ -5,6 +5,12 @@ use byteorder::{WriteBytesExt, LE};
 use io_ext::WriterExt;
 
 impl BinTree {
+    /// Writes a BinTree to a writer.
+    ///
+    /// # Arguments
+    ///
+    /// * `writer` - A writer that implements io::Write and io::Seek.
+    /// * `legacy` - Whether to write in legacy format.
     pub fn to_writer<W: io::Write + io::Seek + ?Sized>(
         &self,
         writer: &mut W,

crates/league-toolkit/src/core/meta/property/value/optional.rs

@@ -6,15 +6,16 @@ use crate::core::meta::{
 };
 use io_ext::{ReaderExt as _, WriterExt as _};
 
-// I am not a fan of the double tagging, but fixing it would be a whole ordeal (and might not be
-// possible with static dispatch?).
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Clone, PartialEq, Debug)]
-pub struct OptionalValue(pub BinPropertyKind, pub Option<Box<PropertyValueEnum>>);
+pub struct OptionalValue {
+    kind: BinPropertyKind,
+    value: Option<Box<PropertyValueEnum>>,
+}
 
 impl PropertyValue for OptionalValue {
     fn size_no_header(&self) -> usize {
-        2 + match &self.1 {
+        2 + match &self.value {
             Some(inner) => inner.size_no_header(),
             None => 0,
         }
@@ -33,13 +34,13 @@ impl ReadProperty for OptionalValue {
 
         let is_some = reader.read_bool()?;
 
-        Ok(Self(
+        Ok(Self {
             kind,
-            match is_some {
+            value: match is_some {
                 true => Some(kind.read(reader, legacy)?.into()),
                 false => None,
             },
-        ))
+        })
     }
 }
 impl WriteProperty for OptionalValue {
@@ -51,9 +52,9 @@ impl WriteProperty for OptionalValue {
         if legacy {
             unimplemented!("legacy optional write")
         }
-        writer.write_property_kind(self.0)?;
-        writer.write_bool(self.1.is_some())?;
-        if let Some(value) = &self.1 {
+        writer.write_property_kind(self.kind)?;
+        writer.write_bool(self.value.is_some())?;
+        if let Some(value) = &self.value {
             value.to_writer(writer)?;
         }
 

crates/league-toolkit/src/core/meta/traits.rs

@@ -1,9 +1,12 @@
 use std::io;
 
 use super::property::{value::*, BinPropertyKind};
+use byteorder::{ReadBytesExt, WriteBytesExt};
 use enum_dispatch::enum_dispatch;
 
 const HEADER_SIZE: usize = 5;
+
+/// Trait for property values
 #[enum_dispatch]
 pub trait PropertyValue {
     fn size(&self, include_header: bool) -> usize {
@@ -16,14 +19,15 @@ pub trait PropertyValue {
     fn size_no_header(&self) -> usize;
 }
 
+/// Trait for reading property values
 pub trait ReadProperty: Sized {
     fn from_reader<R: io::Read + io::Seek + ?Sized>(
         reader: &mut R,
         legacy: bool,
     ) -> Result<Self, crate::core::meta::ParseError>;
 }
 
-use byteorder::ReadBytesExt as _;
+/// Extension trait for reading property values
 pub trait ReaderExt: io::Read {
     /// Reads a u8 as a property kind
     fn read_property_kind(
@@ -36,6 +40,7 @@ pub trait ReaderExt: io::Read {
 
 impl<R: io::Read + ?Sized> ReaderExt for R {}
 
+/// Trait for writing property values
 pub trait WriteProperty: Sized {
     fn to_writer<R: io::Write + io::Seek + ?Sized>(
         &self,
@@ -44,7 +49,7 @@ pub trait WriteProperty: Sized {
     ) -> Result<(), io::Error>;
 }
 
-use byteorder::WriteBytesExt as _;
+/// Extension trait for writing property kinds
 pub trait WriterExt: io::Write {
     fn write_property_kind(&mut self, kind: BinPropertyKind) -> Result<(), io::Error> {
         self.write_u8(kind.into())