add inline tags to functions (#2)

jadebenn · web-flow · commit 134fc9784c36 · 2025-08-06T00:17:17.000-05:00
diff --git a/src/deserialize.rs b/src/deserialize.rs
@@ -297,6 +297,7 @@ pub trait Deserialize<E: Endianness, R>: Sized {
 
 /// Reads a bool by reading a byte, returning false for 0, true for 1, and an `InvalidData` error for any other value.
 impl<E: Endianness, R: Read> Deserialize<E, R> for bool {
+    #[inline]
     fn deserialize(reader: &mut R) -> Res<Self> {
         let mut buf = [0; size_of::<Self>()];
         reader.read_exact(&mut buf)?;
@@ -312,6 +313,7 @@ impl<E: Endianness, R: Read> Deserialize<E, R> for bool {
 }
 
 impl<E: Endianness, R: Read> Deserialize<E, R> for i8 {
+    #[inline]
     fn deserialize(reader: &mut R) -> Res<Self> {
         let mut buf = [0; size_of::<Self>()];
         reader.read_exact(&mut buf)?;
@@ -320,6 +322,7 @@ impl<E: Endianness, R: Read> Deserialize<E, R> for i8 {
 }
 
 impl<E: Endianness, R: Read> Deserialize<E, R> for u8 {
+    #[inline]
     fn deserialize(reader: &mut R) -> Res<Self> {
         let mut buf = [0; size_of::<Self>()];
         reader.read_exact(&mut buf)?;
@@ -330,6 +333,7 @@ impl<E: Endianness, R: Read> Deserialize<E, R> for u8 {
 macro_rules! impl_int {
     ($t:ident) => {
         impl<R: Read> Deserialize<BigEndian, R> for $t {
+            #[inline]
             fn deserialize(reader: &mut R) -> Res<Self> {
                 let mut buf = [0; size_of::<Self>()];
                 reader.read_exact(&mut buf)?;
@@ -338,6 +342,7 @@ macro_rules! impl_int {
         }
 
         impl<R: Read> Deserialize<LittleEndian, R> for $t {
+            #[inline]
             fn deserialize(reader: &mut R) -> Res<Self> {
                 let mut buf = [0; size_of::<Self>()];
                 reader.read_exact(&mut buf)?;
@@ -382,6 +387,7 @@ impl<E: Endianness, R: ERead<E>> Deserialize<E, R> for f32
 where
     u32: Deserialize<E, R>,
 {
+    #[inline]
     fn deserialize(reader: &mut R) -> Res<Self> {
         let ival: u32 = reader.read()?;
         Ok(Self::from_bits(ival))
@@ -392,13 +398,15 @@ impl<E: Endianness, R: ERead<E>> Deserialize<E, R> for f64
 where
     u64: Deserialize<E, R>,
 {
+    #[inline]
     fn deserialize(reader: &mut R) -> Res<Self> {
         let ival: u64 = reader.read()?;
         Ok(Self::from_bits(ival))
     }
 }
 
 impl<E: Endianness, R: Read> Deserialize<E, R> for Ipv4Addr {
+    #[inline]
     fn deserialize(reader: &mut R) -> Res<Self> {
         let mut buf = [0; 4];
         reader.read_exact(&mut buf)?;
@@ -411,6 +419,7 @@ impl<E: Endianness, R: ERead<E>, T: Deserialize<E, R>> Deserialize<E, R> for Opt
 where
     bool: Deserialize<E, R>,
 {
+    #[inline]
     fn deserialize(reader: &mut R) -> Res<Self> {
         let is_some: bool = reader.read()?;
         Ok(if is_some { Some(reader.read()?) } else { None })
diff --git a/src/read.rs b/src/read.rs
@@ -27,14 +27,17 @@ pub trait ERead<E: Endianness>: Sized {
     /// Reads a `Deserialize` from the reader, in the reader's endianness.
     ///
     /// What's actually read is up to the implementation of the `Deserialize`.
+    #[inline]
     fn read<D: Deserialize<E, Self>>(&mut self) -> Res<D> {
         D::deserialize(self)
     }
     /// Reads in forced big endian.
+    #[inline]
     fn read_be<D: Deserialize<BigEndian, Self>>(&mut self) -> Res<D> {
         D::deserialize(self)
     }
     /// Reads in forced little endian.
+    #[inline]
     fn read_le<D: Deserialize<LittleEndian, Self>>(&mut self) -> Res<D> {
         D::deserialize(self)
     }
@@ -47,12 +50,15 @@ pub trait ERead<E: Endianness>: Sized {
 ///
 /// This exists solely to make `use` notation work. See `ERead` for documentation.
 pub trait BERead: Sized {
+    #[inline]
     fn read<D: Deserialize<BigEndian, Self>>(&mut self) -> Res<D> {
         D::deserialize(self)
     }
+    #[inline]
     fn read_be<D: Deserialize<BigEndian, Self>>(&mut self) -> Res<D> {
         D::deserialize(self)
     }
+    #[inline]
     fn read_le<D: Deserialize<LittleEndian, Self>>(&mut self) -> Res<D> {
         D::deserialize(self)
     }
@@ -64,12 +70,15 @@ pub trait BERead: Sized {
 ///
 /// This exists solely to make `use` notation work. See `ERead` for documentation.
 pub trait LERead: Sized {
+    #[inline]
     fn read<D: Deserialize<LittleEndian, Self>>(&mut self) -> Res<D> {
         D::deserialize(self)
     }
+    #[inline]
     fn read_be<D: Deserialize<BigEndian, Self>>(&mut self) -> Res<D> {
         D::deserialize(self)
     }
+    #[inline]
     fn read_le<D: Deserialize<LittleEndian, Self>>(&mut self) -> Res<D> {
         D::deserialize(self)
     }
diff --git a/src/serialize.rs b/src/serialize.rs
@@ -292,11 +292,13 @@ pub trait Serialize<E: Endianness, W> {
 macro_rules! impl_ref {
     ($t:ident) => {
         impl<W: Write + BEWrite> Serialize<BigEndian, W> for &$t {
+            #[inline]
             fn serialize(self, writer: &mut W) -> Res<()> {
                 BEWrite::write(writer, *self)
             }
         }
         impl<W: Write + LEWrite> Serialize<LittleEndian, W> for &$t {
+            #[inline]
             fn serialize(self, writer: &mut W) -> Res<()> {
                 LEWrite::write(writer, *self)
             }
@@ -307,12 +309,14 @@ macro_rules! impl_ref {
 macro_rules! impl_int {
     ($t:ident) => {
         impl<W: Write> Serialize<BigEndian, W> for $t {
+            #[inline]
             fn serialize(self, writer: &mut W) -> Res<()> {
                 writer.write_all(&self.to_be_bytes())
             }
         }
 
         impl<W: Write> Serialize<LittleEndian, W> for $t {
+            #[inline]
             fn serialize(self, writer: &mut W) -> Res<()> {
                 writer.write_all(&self.to_le_bytes())
             }
@@ -361,6 +365,7 @@ impl<E: Endianness, W: EWrite<E>> Serialize<E, W> for f32
 where
     u32: Serialize<E, W>,
 {
+    #[inline]
     fn serialize(self, writer: &mut W) -> Res<()> {
         writer.write(self.to_bits())
     }
@@ -371,6 +376,7 @@ impl<E: Endianness, W: EWrite<E>> Serialize<E, W> for f64
 where
     u64: Serialize<E, W>,
 {
+    #[inline]
     fn serialize(self, writer: &mut W) -> Res<()> {
         writer.write(self.to_bits())
     }
@@ -379,13 +385,15 @@ impl_ref!(f64);
 
 /// Writes a bool by writing a byte.
 impl<E: Endianness, W: Write> Serialize<E, W> for bool {
+    #[inline]
     fn serialize(self, writer: &mut W) -> Res<()> {
         writer.write_all(&u8::from(self).to_ne_bytes())
     }
 }
 impl_ref!(bool);
 
 impl<E: Endianness, W: Write> Serialize<E, W> for Ipv4Addr {
+    #[inline]
     fn serialize(self, writer: &mut W) -> Res<()> {
         writer.write_all(&self.octets()[..])
     }
@@ -398,6 +406,7 @@ impl<E: Endianness, W: EWrite<E>, S> Serialize<E, W> for &[S]
 where
     for<'a> &'a S: Serialize<E, W>,
 {
+    #[inline]
     fn serialize(self, writer: &mut W) -> Res<()> {
         for elem in self {
             writer.write(elem)?;
@@ -411,6 +420,7 @@ impl<E: Endianness, W: EWrite<E>, S> Serialize<E, W> for &Vec<S>
 where
     for<'a> &'a S: Serialize<E, W>,
 {
+    #[inline]
     fn serialize(self, writer: &mut W) -> Res<()> {
         writer.write(self.as_slice())
     }
@@ -422,6 +432,7 @@ where
     bool: Serialize<E, W>,
     for<'a> &'a S: Serialize<E, W>,
 {
+    #[inline]
     fn serialize(self, writer: &mut W) -> Res<()> {
         writer.write(self.is_some())?;
         if let Some(x) = self {
diff --git a/src/write.rs b/src/write.rs
@@ -26,14 +26,17 @@ pub trait EWrite<E: Endianness>: Sized {
     /// Writes a `Serialize` to the writer, in the writer's endianness.
     ///
     /// What's actually written is up to the implementation of the `Serialize`.
+    #[inline]
     fn write<S: Serialize<E, Self>>(&mut self, ser: S) -> Res<()> {
         ser.serialize(self)
     }
     /// Writes in forced big endian.
+    #[inline]
     fn write_be<S: Serialize<BigEndian, Self>>(&mut self, ser: S) -> Res<()> {
         ser.serialize(self)
     }
     /// Writes in forced little endian.
+    #[inline]
     fn write_le<S: Serialize<LittleEndian, Self>>(&mut self, ser: S) -> Res<()> {
         ser.serialize(self)
     }
@@ -46,12 +49,15 @@ pub trait EWrite<E: Endianness>: Sized {
 ///
 /// This exists solely to make `use` notation work. See `EWrite` for documentation.
 pub trait BEWrite: Sized {
+    #[inline]
     fn write<S: Serialize<BigEndian, Self>>(&mut self, ser: S) -> Res<()> {
         ser.serialize(self)
     }
+    #[inline]
     fn write_be<S: Serialize<BigEndian, Self>>(&mut self, ser: S) -> Res<()> {
         ser.serialize(self)
     }
+    #[inline]
     fn write_le<S: Serialize<LittleEndian, Self>>(&mut self, ser: S) -> Res<()> {
         ser.serialize(self)
     }
@@ -63,12 +69,15 @@ pub trait BEWrite: Sized {
 ///
 /// This exists solely to make `use` notation work. See `EWrite` for documentation.
 pub trait LEWrite: Sized {
+    #[inline]
     fn write<S: Serialize<LittleEndian, Self>>(&mut self, ser: S) -> Res<()> {
         ser.serialize(self)
     }
+    #[inline]
     fn write_be<S: Serialize<BigEndian, Self>>(&mut self, ser: S) -> Res<()> {
         ser.serialize(self)
     }
+    #[inline]
     fn write_le<S: Serialize<LittleEndian, Self>>(&mut self, ser: S) -> Res<()> {
         ser.serialize(self)
     }

Original file line number	Diff line number	Diff line change
`@@ -27,14 +27,17 @@ pub trait ERead<E: Endianness>: Sized {`
`27`	`27`	/// Reads a `Deserialize` from the reader, in the reader's endianness.
`28`	`28`	`///`
`29`	`29`	/// What's actually read is up to the implementation of the `Deserialize`.
	`30`	`+ #[inline]`
`30`	`31`	`fn read<D: Deserialize<E, Self>>(&mut self) -> Res<D> {`
`31`	`32`	`D::deserialize(self)`
`32`	`33`	`}`
`33`	`34`	`/// Reads in forced big endian.`
	`35`	`+ #[inline]`
`34`	`36`	`fn read_be<D: Deserialize<BigEndian, Self>>(&mut self) -> Res<D> {`
`35`	`37`	`D::deserialize(self)`
`36`	`38`	`}`
`37`	`39`	`/// Reads in forced little endian.`
	`40`	`+ #[inline]`
`38`	`41`	`fn read_le<D: Deserialize<LittleEndian, Self>>(&mut self) -> Res<D> {`
`39`	`42`	`D::deserialize(self)`
`40`	`43`	`}`
`@@ -47,12 +50,15 @@ pub trait ERead<E: Endianness>: Sized {`
`47`	`50`	`///`
`48`	`51`	/// This exists solely to make `use` notation work. See `ERead` for documentation.
`49`	`52`	`pub trait BERead: Sized {`
	`53`	`+ #[inline]`
`50`	`54`	`fn read<D: Deserialize<BigEndian, Self>>(&mut self) -> Res<D> {`
`51`	`55`	`D::deserialize(self)`
`52`	`56`	`}`
	`57`	`+ #[inline]`
`53`	`58`	`fn read_be<D: Deserialize<BigEndian, Self>>(&mut self) -> Res<D> {`
`54`	`59`	`D::deserialize(self)`
`55`	`60`	`}`
	`61`	`+ #[inline]`
`56`	`62`	`fn read_le<D: Deserialize<LittleEndian, Self>>(&mut self) -> Res<D> {`
`57`	`63`	`D::deserialize(self)`
`58`	`64`	`}`
`@@ -64,12 +70,15 @@ pub trait BERead: Sized {`
`64`	`70`	`///`
`65`	`71`	/// This exists solely to make `use` notation work. See `ERead` for documentation.
`66`	`72`	`pub trait LERead: Sized {`
	`73`	`+ #[inline]`
`67`	`74`	`fn read<D: Deserialize<LittleEndian, Self>>(&mut self) -> Res<D> {`
`68`	`75`	`D::deserialize(self)`
`69`	`76`	`}`
	`77`	`+ #[inline]`
`70`	`78`	`fn read_be<D: Deserialize<BigEndian, Self>>(&mut self) -> Res<D> {`
`71`	`79`	`D::deserialize(self)`
`72`	`80`	`}`
	`81`	`+ #[inline]`
`73`	`82`	`fn read_le<D: Deserialize<LittleEndian, Self>>(&mut self) -> Res<D> {`
`74`	`83`	`D::deserialize(self)`
`75`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -292,11 +292,13 @@ pub trait Serialize<E: Endianness, W> {`
`292`	`292`	`macro_rules! impl_ref {`
`293`	`293`	`($t:ident) => {`
`294`	`294`	`impl<W: Write + BEWrite> Serialize<BigEndian, W> for &$t {`
	`295`	`+ #[inline]`
`295`	`296`	`fn serialize(self, writer: &mut W) -> Res<()> {`
`296`	`297`	`BEWrite::write(writer, *self)`
`297`	`298`	`}`
`298`	`299`	`}`
`299`	`300`	`impl<W: Write + LEWrite> Serialize<LittleEndian, W> for &$t {`
	`301`	`+ #[inline]`
`300`	`302`	`fn serialize(self, writer: &mut W) -> Res<()> {`
`301`	`303`	`LEWrite::write(writer, *self)`
`302`	`304`	`}`
`@@ -307,12 +309,14 @@ macro_rules! impl_ref {`
`307`	`309`	`macro_rules! impl_int {`
`308`	`310`	`($t:ident) => {`
`309`	`311`	`impl<W: Write> Serialize<BigEndian, W> for $t {`
	`312`	`+ #[inline]`
`310`	`313`	`fn serialize(self, writer: &mut W) -> Res<()> {`
`311`	`314`	`writer.write_all(&self.to_be_bytes())`
`312`	`315`	`}`
`313`	`316`	`}`
`314`	`317`
`315`	`318`	`impl<W: Write> Serialize<LittleEndian, W> for $t {`
	`319`	`+ #[inline]`
`316`	`320`	`fn serialize(self, writer: &mut W) -> Res<()> {`
`317`	`321`	`writer.write_all(&self.to_le_bytes())`
`318`	`322`	`}`
`@@ -361,6 +365,7 @@ impl<E: Endianness, W: EWrite<E>> Serialize<E, W> for f32`
`361`	`365`	`where`
`362`	`366`	`u32: Serialize<E, W>,`
`363`	`367`	`{`
	`368`	`+ #[inline]`
`364`	`369`	`fn serialize(self, writer: &mut W) -> Res<()> {`
`365`	`370`	`writer.write(self.to_bits())`
`366`	`371`	`}`
`@@ -371,6 +376,7 @@ impl<E: Endianness, W: EWrite<E>> Serialize<E, W> for f64`
`371`	`376`	`where`
`372`	`377`	`u64: Serialize<E, W>,`
`373`	`378`	`{`
	`379`	`+ #[inline]`
`374`	`380`	`fn serialize(self, writer: &mut W) -> Res<()> {`
`375`	`381`	`writer.write(self.to_bits())`
`376`	`382`	`}`
`@@ -379,13 +385,15 @@ impl_ref!(f64);`
`379`	`385`
`380`	`386`	`/// Writes a bool by writing a byte.`
`381`	`387`	`impl<E: Endianness, W: Write> Serialize<E, W> for bool {`
	`388`	`+ #[inline]`
`382`	`389`	`fn serialize(self, writer: &mut W) -> Res<()> {`
`383`	`390`	`writer.write_all(&u8::from(self).to_ne_bytes())`
`384`	`391`	`}`
`385`	`392`	`}`
`386`	`393`	`impl_ref!(bool);`
`387`	`394`
`388`	`395`	`impl<E: Endianness, W: Write> Serialize<E, W> for Ipv4Addr {`
	`396`	`+ #[inline]`
`389`	`397`	`fn serialize(self, writer: &mut W) -> Res<()> {`
`390`	`398`	`writer.write_all(&self.octets()[..])`
`391`	`399`	`}`
`@@ -398,6 +406,7 @@ impl<E: Endianness, W: EWrite<E>, S> Serialize<E, W> for &[S]`
`398`	`406`	`where`
`399`	`407`	`for<'a> &'a S: Serialize<E, W>,`
`400`	`408`	`{`
	`409`	`+ #[inline]`
`401`	`410`	`fn serialize(self, writer: &mut W) -> Res<()> {`
`402`	`411`	`for elem in self {`
`403`	`412`	`writer.write(elem)?;`
`@@ -411,6 +420,7 @@ impl<E: Endianness, W: EWrite<E>, S> Serialize<E, W> for &Vec<S>`
`411`	`420`	`where`
`412`	`421`	`for<'a> &'a S: Serialize<E, W>,`
`413`	`422`	`{`
	`423`	`+ #[inline]`
`414`	`424`	`fn serialize(self, writer: &mut W) -> Res<()> {`
`415`	`425`	`writer.write(self.as_slice())`
`416`	`426`	`}`
`@@ -422,6 +432,7 @@ where`
`422`	`432`	`bool: Serialize<E, W>,`
`423`	`433`	`for<'a> &'a S: Serialize<E, W>,`
`424`	`434`	`{`
	`435`	`+ #[inline]`
`425`	`436`	`fn serialize(self, writer: &mut W) -> Res<()> {`
`426`	`437`	`writer.write(self.is_some())?;`
`427`	`438`	`if let Some(x) = self {`
Original file line number	Diff line number	Diff line change
`@@ -26,14 +26,17 @@ pub trait EWrite<E: Endianness>: Sized {`
`26`	`26`	/// Writes a `Serialize` to the writer, in the writer's endianness.
`27`	`27`	`///`
`28`	`28`	/// What's actually written is up to the implementation of the `Serialize`.
	`29`	`+ #[inline]`
`29`	`30`	`fn write<S: Serialize<E, Self>>(&mut self, ser: S) -> Res<()> {`
`30`	`31`	`ser.serialize(self)`
`31`	`32`	`}`
`32`	`33`	`/// Writes in forced big endian.`
	`34`	`+ #[inline]`
`33`	`35`	`fn write_be<S: Serialize<BigEndian, Self>>(&mut self, ser: S) -> Res<()> {`
`34`	`36`	`ser.serialize(self)`
`35`	`37`	`}`
`36`	`38`	`/// Writes in forced little endian.`
	`39`	`+ #[inline]`
`37`	`40`	`fn write_le<S: Serialize<LittleEndian, Self>>(&mut self, ser: S) -> Res<()> {`
`38`	`41`	`ser.serialize(self)`
`39`	`42`	`}`
`@@ -46,12 +49,15 @@ pub trait EWrite<E: Endianness>: Sized {`
`46`	`49`	`///`
`47`	`50`	/// This exists solely to make `use` notation work. See `EWrite` for documentation.
`48`	`51`	`pub trait BEWrite: Sized {`
	`52`	`+ #[inline]`
`49`	`53`	`fn write<S: Serialize<BigEndian, Self>>(&mut self, ser: S) -> Res<()> {`
`50`	`54`	`ser.serialize(self)`
`51`	`55`	`}`
	`56`	`+ #[inline]`
`52`	`57`	`fn write_be<S: Serialize<BigEndian, Self>>(&mut self, ser: S) -> Res<()> {`
`53`	`58`	`ser.serialize(self)`
`54`	`59`	`}`
	`60`	`+ #[inline]`
`55`	`61`	`fn write_le<S: Serialize<LittleEndian, Self>>(&mut self, ser: S) -> Res<()> {`
`56`	`62`	`ser.serialize(self)`
`57`	`63`	`}`
`@@ -63,12 +69,15 @@ pub trait BEWrite: Sized {`
`63`	`69`	`///`
`64`	`70`	/// This exists solely to make `use` notation work. See `EWrite` for documentation.
`65`	`71`	`pub trait LEWrite: Sized {`
	`72`	`+ #[inline]`
`66`	`73`	`fn write<S: Serialize<LittleEndian, Self>>(&mut self, ser: S) -> Res<()> {`
`67`	`74`	`ser.serialize(self)`
`68`	`75`	`}`
	`76`	`+ #[inline]`
`69`	`77`	`fn write_be<S: Serialize<BigEndian, Self>>(&mut self, ser: S) -> Res<()> {`
`70`	`78`	`ser.serialize(self)`
`71`	`79`	`}`
	`80`	`+ #[inline]`
`72`	`81`	`fn write_le<S: Serialize<LittleEndian, Self>>(&mut self, ser: S) -> Res<()> {`
`73`	`82`	`ser.serialize(self)`
`74`	`83`	`}`