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/structs/de.rs    | 17 +++++++++++++++++
 src/structs/error.rs |  2 +-
 src/structs/ser.rs   | 28 ++++++++++++++++++++++++++++
 3 files changed, 46 insertions(+), 1 deletion(-)

(limited to 'src/structs')

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(())
     }
-- 
cgit v1.2.3