From 5f4ceda88c7299deb317f8d22a99ab2521c5a380 Mon Sep 17 00:00:00 2001
From: Igor Tolmachev <me@igorek.dev>
Date: Wed, 17 Jul 2024 17:38:19 +0900
Subject: Add more `#[inline]` markers

---
 src/error.rs          |  2 +-
 src/structs/de.rs     | 17 +++++++++++++++++
 src/structs/error.rs  |  2 +-
 src/structs/ser.rs    | 28 ++++++++++++++++++++++++++++
 src/zip/cp437.rs      |  2 ++
 src/zip/encryption.rs | 22 +++++++++++-----------
 src/zip/error.rs      |  2 +-
 src/zip/structs.rs    |  2 ++
 8 files changed, 63 insertions(+), 14 deletions(-)

(limited to 'src')

diff --git a/src/error.rs b/src/error.rs
index 518b0e9..b7866d7 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -8,7 +8,7 @@ pub type ArchiveResult<T, E> = Result<T, ArchiveError<E>>;
 pub enum ArchiveError<E: Error> {
     Io { error: io::Error },
     Serde { message: String },
-    Archivator { module: String, error: E },
+    Archivator { module: &'static str, error: E },
 }
 
 impl<E: Error> From<io::Error> for ArchiveError<E> {
diff --git a/src/structs/de.rs b/src/structs/de.rs
index 9158d90..edd8011 100644
--- a/src/structs/de.rs
+++ b/src/structs/de.rs
@@ -62,6 +62,7 @@ impl<'a, 'de> EnumDeserializer<'a, 'de> {
 impl<'de> de::Deserializer<'de> for &mut ArchiveDeserializer<'de> {
     type Error = ArchiveError<StructError>;
 
+    #[inline]
     fn deserialize_any<V>(self, _visitor: V) -> StructResult<V::Value>
     where
         V: de::Visitor<'de>,
@@ -154,6 +155,7 @@ impl<'de> de::Deserializer<'de> for &mut ArchiveDeserializer<'de> {
         visitor.visit_f64(self.settings.byte_order.to_f64(bytes))
     }
 
+    #[inline]
     fn deserialize_char<V>(self, _visitor: V) -> StructResult<V::Value>
     where
         V: de::Visitor<'de>,
@@ -161,6 +163,7 @@ impl<'de> de::Deserializer<'de> for &mut ArchiveDeserializer<'de> {
         Err(StructError::DeserializationNotSupported { type_name: "char" }.into())
     }
 
+    #[inline]
     fn deserialize_str<V>(self, _visitor: V) -> StructResult<V::Value>
     where
         V: de::Visitor<'de>,
@@ -168,6 +171,7 @@ impl<'de> de::Deserializer<'de> for &mut ArchiveDeserializer<'de> {
         Err(StructError::DeserializationNotSupported { type_name: "str" }.into())
     }
 
+    #[inline]
     fn deserialize_string<V>(self, _visitor: V) -> StructResult<V::Value>
     where
         V: de::Visitor<'de>,
@@ -178,6 +182,7 @@ impl<'de> de::Deserializer<'de> for &mut ArchiveDeserializer<'de> {
         .into())
     }
 
+    #[inline]
     fn deserialize_bytes<V>(self, _visitor: V) -> StructResult<V::Value>
     where
         V: de::Visitor<'de>,
@@ -185,6 +190,7 @@ impl<'de> de::Deserializer<'de> for &mut ArchiveDeserializer<'de> {
         Err(StructError::DeserializationNotSupported { type_name: "bytes" }.into())
     }
 
+    #[inline]
     fn deserialize_byte_buf<V>(self, _visitor: V) -> StructResult<V::Value>
     where
         V: de::Visitor<'de>,
@@ -192,6 +198,7 @@ impl<'de> de::Deserializer<'de> for &mut ArchiveDeserializer<'de> {
         Err(StructError::DeserializationNotSupported { type_name: "bytes" }.into())
     }
 
+    #[inline]
     fn deserialize_option<V>(self, _visitor: V) -> StructResult<V::Value>
     where
         V: de::Visitor<'de>,
@@ -202,6 +209,7 @@ impl<'de> de::Deserializer<'de> for &mut ArchiveDeserializer<'de> {
         .into())
     }
 
+    #[inline]
     fn deserialize_unit<V>(self, visitor: V) -> StructResult<V::Value>
     where
         V: de::Visitor<'de>,
@@ -209,6 +217,7 @@ impl<'de> de::Deserializer<'de> for &mut ArchiveDeserializer<'de> {
         visitor.visit_unit()
     }
 
+    #[inline]
     fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> StructResult<V::Value>
     where
         V: de::Visitor<'de>,
@@ -216,6 +225,7 @@ impl<'de> de::Deserializer<'de> for &mut ArchiveDeserializer<'de> {
         self.deserialize_unit(visitor)
     }
 
+    #[inline]
     fn deserialize_newtype_struct<V>(
         self,
         _name: &'static str,
@@ -227,6 +237,7 @@ impl<'de> de::Deserializer<'de> for &mut ArchiveDeserializer<'de> {
         visitor.visit_newtype_struct(self)
     }
 
+    #[inline]
     fn deserialize_seq<V>(self, _visitor: V) -> StructResult<V::Value>
     where
         V: de::Visitor<'de>,
@@ -234,6 +245,7 @@ impl<'de> de::Deserializer<'de> for &mut ArchiveDeserializer<'de> {
         Err(StructError::DeserializationNotSupported { type_name: "seq" }.into())
     }
 
+    #[inline]
     fn deserialize_tuple<V>(self, len: usize, visitor: V) -> StructResult<V::Value>
     where
         V: de::Visitor<'de>,
@@ -241,6 +253,7 @@ impl<'de> de::Deserializer<'de> for &mut ArchiveDeserializer<'de> {
         visitor.visit_seq(SeqDeserializer::new(self, len))
     }
 
+    #[inline]
     fn deserialize_tuple_struct<V>(
         self,
         _name: &'static str,
@@ -253,6 +266,7 @@ impl<'de> de::Deserializer<'de> for &mut ArchiveDeserializer<'de> {
         self.deserialize_tuple(len, visitor)
     }
 
+    #[inline]
     fn deserialize_map<V>(self, _visitor: V) -> StructResult<V::Value>
     where
         V: de::Visitor<'de>,
@@ -260,6 +274,7 @@ impl<'de> de::Deserializer<'de> for &mut ArchiveDeserializer<'de> {
         Err(StructError::DeserializationNotSupported { type_name: "map" }.into())
     }
 
+    #[inline]
     fn deserialize_struct<V>(
         self,
         _name: &'static str,
@@ -272,6 +287,7 @@ impl<'de> de::Deserializer<'de> for &mut ArchiveDeserializer<'de> {
         self.deserialize_tuple(fields.len(), visitor)
     }
 
+    #[inline]
     fn deserialize_enum<V>(
         self,
         _name: &'static str,
@@ -334,6 +350,7 @@ impl<'a, 'de> de::EnumAccess<'de> for EnumDeserializer<'a, 'de> {
 impl<'a, 'de> de::VariantAccess<'de> for EnumDeserializer<'a, 'de> {
     type Error = ArchiveError<StructError>;
 
+    #[inline]
     fn unit_variant(self) -> Result<(), Self::Error> {
         Ok(())
     }
diff --git a/src/structs/error.rs b/src/structs/error.rs
index 3e74e45..f07163c 100644
--- a/src/structs/error.rs
+++ b/src/structs/error.rs
@@ -14,7 +14,7 @@ pub enum StructError {
 impl From<StructError> for ArchiveError<StructError> {
     fn from(value: StructError) -> Self {
         Self::Archivator {
-            module: "Struct serializer".to_string(),
+            module: "Struct serializer",
             error: value,
         }
     }
diff --git a/src/structs/ser.rs b/src/structs/ser.rs
index 5c26182..f7e694a 100644
--- a/src/structs/ser.rs
+++ b/src/structs/ser.rs
@@ -87,18 +87,22 @@ impl ser::Serializer for &mut ArchiveSerializer {
         Ok(())
     }
 
+    #[inline]
     fn serialize_char(self, _v: char) -> StructResult<()> {
         Err(StructError::SerializationNotSupported { type_name: "char" }.into())
     }
 
+    #[inline]
     fn serialize_str(self, _v: &str) -> StructResult<()> {
         Err(StructError::SerializationNotSupported { type_name: "str" }.into())
     }
 
+    #[inline]
     fn serialize_bytes(self, _v: &[u8]) -> StructResult<()> {
         Err(StructError::SerializationNotSupported { type_name: "bytes" }.into())
     }
 
+    #[inline]
     fn serialize_none(self) -> StructResult<()> {
         Err(StructError::SerializationNotSupported {
             type_name: "optional",
@@ -106,6 +110,7 @@ impl ser::Serializer for &mut ArchiveSerializer {
         .into())
     }
 
+    #[inline]
     fn serialize_some<T>(self, _value: &T) -> StructResult<()>
     where
         T: ?Sized + Serialize,
@@ -116,10 +121,12 @@ impl ser::Serializer for &mut ArchiveSerializer {
         .into())
     }
 
+    #[inline]
     fn serialize_unit(self) -> StructResult<()> {
         Ok(())
     }
 
+    #[inline]
     fn serialize_unit_struct(self, _name: &'static str) -> StructResult<()> {
         self.serialize_unit()
     }
@@ -139,6 +146,7 @@ impl ser::Serializer for &mut ArchiveSerializer {
         Ok(())
     }
 
+    #[inline]
     fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> StructResult<()>
     where
         T: ?Sized + Serialize,
@@ -165,14 +173,17 @@ impl ser::Serializer for &mut ArchiveSerializer {
         value.serialize(self)
     }
 
+    #[inline]
     fn serialize_seq(self, _len: Option<usize>) -> StructResult<Self::SerializeSeq> {
         Err(StructError::SerializationNotSupported { type_name: "seq" }.into())
     }
 
+    #[inline]
     fn serialize_tuple(self, _len: usize) -> StructResult<Self::SerializeTuple> {
         Ok(self)
     }
 
+    #[inline]
     fn serialize_tuple_struct(
         self,
         _name: &'static str,
@@ -197,10 +208,12 @@ impl ser::Serializer for &mut ArchiveSerializer {
         Ok(self)
     }
 
+    #[inline]
     fn serialize_map(self, _len: Option<usize>) -> StructResult<Self::SerializeMap> {
         Err(StructError::SerializationNotSupported { type_name: "map" }.into())
     }
 
+    #[inline]
     fn serialize_struct(
         self,
         _name: &'static str,
@@ -230,6 +243,7 @@ impl ser::SerializeSeq for &mut ArchiveSerializer {
     type Ok = ();
     type Error = ArchiveError<StructError>;
 
+    #[inline]
     fn serialize_element<T>(&mut self, _value: &T) -> StructResult<()>
     where
         T: ?Sized + Serialize,
@@ -237,6 +251,7 @@ impl ser::SerializeSeq for &mut ArchiveSerializer {
         Err(StructError::SerializationNotSupported { type_name: "seq" }.into())
     }
 
+    #[inline]
     fn end(self) -> StructResult<()> {
         Err(StructError::SerializationNotSupported { type_name: "seq" }.into())
     }
@@ -246,6 +261,7 @@ impl ser::SerializeTuple for &mut ArchiveSerializer {
     type Ok = ();
     type Error = ArchiveError<StructError>;
 
+    #[inline]
     fn serialize_element<T>(&mut self, value: &T) -> StructResult<()>
     where
         T: ?Sized + Serialize,
@@ -253,6 +269,7 @@ impl ser::SerializeTuple for &mut ArchiveSerializer {
         value.serialize(&mut **self)
     }
 
+    #[inline]
     fn end(self) -> StructResult<()> {
         Ok(())
     }
@@ -262,6 +279,7 @@ impl ser::SerializeTupleStruct for &mut ArchiveSerializer {
     type Ok = ();
     type Error = ArchiveError<StructError>;
 
+    #[inline]
     fn serialize_field<T>(&mut self, value: &T) -> StructResult<()>
     where
         T: ?Sized + Serialize,
@@ -269,6 +287,7 @@ impl ser::SerializeTupleStruct for &mut ArchiveSerializer {
         value.serialize(&mut **self)
     }
 
+    #[inline]
     fn end(self) -> StructResult<()> {
         Ok(())
     }
@@ -278,6 +297,7 @@ impl ser::SerializeTupleVariant for &mut ArchiveSerializer {
     type Ok = ();
     type Error = ArchiveError<StructError>;
 
+    #[inline]
     fn serialize_field<T>(&mut self, value: &T) -> StructResult<()>
     where
         T: ?Sized + Serialize,
@@ -285,6 +305,7 @@ impl ser::SerializeTupleVariant for &mut ArchiveSerializer {
         value.serialize(&mut **self)
     }
 
+    #[inline]
     fn end(self) -> StructResult<()> {
         Ok(())
     }
@@ -294,6 +315,7 @@ impl ser::SerializeMap for &mut ArchiveSerializer {
     type Ok = ();
     type Error = ArchiveError<StructError>;
 
+    #[inline]
     fn serialize_key<T>(&mut self, _key: &T) -> StructResult<()>
     where
         T: ?Sized + Serialize,
@@ -301,6 +323,7 @@ impl ser::SerializeMap for &mut ArchiveSerializer {
         Err(StructError::SerializationNotSupported { type_name: "map" }.into())
     }
 
+    #[inline]
     fn serialize_value<T>(&mut self, _value: &T) -> StructResult<()>
     where
         T: ?Sized + Serialize,
@@ -308,6 +331,7 @@ impl ser::SerializeMap for &mut ArchiveSerializer {
         Err(StructError::SerializationNotSupported { type_name: "map" }.into())
     }
 
+    #[inline]
     fn end(self) -> StructResult<()> {
         Err(StructError::SerializationNotSupported { type_name: "map" }.into())
     }
@@ -317,6 +341,7 @@ impl ser::SerializeStruct for &mut ArchiveSerializer {
     type Ok = ();
     type Error = ArchiveError<StructError>;
 
+    #[inline]
     fn serialize_field<T>(&mut self, _key: &'static str, value: &T) -> StructResult<()>
     where
         T: ?Sized + Serialize,
@@ -324,6 +349,7 @@ impl ser::SerializeStruct for &mut ArchiveSerializer {
         value.serialize(&mut **self)
     }
 
+    #[inline]
     fn end(self) -> StructResult<()> {
         Ok(())
     }
@@ -333,6 +359,7 @@ impl ser::SerializeStructVariant for &mut ArchiveSerializer {
     type Ok = ();
     type Error = ArchiveError<StructError>;
 
+    #[inline]
     fn serialize_field<T>(&mut self, _key: &'static str, value: &T) -> StructResult<()>
     where
         T: ?Sized + Serialize,
@@ -340,6 +367,7 @@ impl ser::SerializeStructVariant for &mut ArchiveSerializer {
         value.serialize(&mut **self)
     }
 
+    #[inline]
     fn end(self) -> StructResult<()> {
         Ok(())
     }
diff --git a/src/zip/cp437.rs b/src/zip/cp437.rs
index 6f6731a..91a3c00 100644
--- a/src/zip/cp437.rs
+++ b/src/zip/cp437.rs
@@ -343,6 +343,7 @@ pub fn is_cp437(char: char) -> bool {
 impl FromCp437<Vec<u8>> for String {
     type Value = Self;
 
+    #[inline]
     fn from_cp437(bytes: Vec<u8>) -> Self {
         Self::from_cp437(bytes.as_slice())
     }
@@ -351,6 +352,7 @@ impl FromCp437<Vec<u8>> for String {
 impl<const S: usize> FromCp437<[u8; S]> for String {
     type Value = Self;
 
+    #[inline]
     fn from_cp437(bytes: [u8; S]) -> Self {
         Self::from_cp437(bytes.as_slice())
     }
diff --git a/src/zip/encryption.rs b/src/zip/encryption.rs
index 76824a1..f317245 100644
--- a/src/zip/encryption.rs
+++ b/src/zip/encryption.rs
@@ -7,22 +7,22 @@ const TABLE: [u32; 256] = generate_table();
 const fn generate_table() -> [u32; 256] {
     let mut table = [0; 256];
 
-    let mut b = 0;
-    while b <= 255 {
-        let mut crc = b as u32;
+    let mut i = 0;
+    while i <= 255 {
+        let mut t = i as u32;
 
-        let mut i = 0;
-        while i < 8 {
-            if (crc & 1) > 0 {
-                crc = (crc >> 1) ^ 0xEDB88320
+        let mut j = 0;
+        while j < 8 {
+            if (t & 1) > 0 {
+                t = (t >> 1) ^ 0xEDB88320
             } else {
-                crc >>= 1
+                t >>= 1
             }
-            i += 1;
+            j += 1;
         }
 
-        table[b] = crc;
-        b += 1
+        table[i] = t;
+        i += 1
     }
 
     table
diff --git a/src/zip/error.rs b/src/zip/error.rs
index 525a67b..5573cf8 100644
--- a/src/zip/error.rs
+++ b/src/zip/error.rs
@@ -29,7 +29,7 @@ pub enum ZipError {
 impl From<ZipError> for ArchiveError<ZipError> {
     fn from(value: ZipError) -> Self {
         Self::Archivator {
-            module: "Zip".to_string(),
+            module: "Zip",
             error: value,
         }
     }
diff --git a/src/zip/structs.rs b/src/zip/structs.rs
index 9fd1aeb..ebecae7 100644
--- a/src/zip/structs.rs
+++ b/src/zip/structs.rs
@@ -58,11 +58,13 @@ pub struct ExtraHeader {
     pub size: u16,
 }
 
+#[inline]
 #[allow(dead_code)]
 pub fn serialize<T: Serialize>(object: &mut T) -> StructResult<Vec<u8>> {
     Settings::new(ByteOrder::Le, VariantIndexType::U8).serialize(object)
 }
 
+#[inline]
 pub fn deserialize<'de, T: Deserialize<'de>>(object: &'de [u8]) -> StructResult<T> {
     Settings::new(ByteOrder::Le, VariantIndexType::U8).deserialize(object)
 }
-- 
cgit v1.2.3