Minor improvements on macros

Cargo.toml

@@ -12,6 +12,9 @@ log = "0.4"
 serde = "1.0"
 xml-rs = "0.8"
 thiserror = "1.0"
+paste = "1.0.9"
+itoa = "1.0.4"
+ryu = "1.0.11"
 
 [dev-dependencies]
 serde = { version = "1.0", features = ["derive"] }

src/de/map.rs

@@ -1,5 +1,6 @@
 use std::io::Read;
 
+use paste::paste;
 use serde::de::{self, IntoDeserializer, Unexpected};
 use serde::forward_to_deserialize_any;
 use xml::attribute::OwnedAttribute;
@@ -88,31 +89,14 @@ impl<'de, 'a, R: 'a + Read, B: BufferedXmlReader<R>> de::MapAccess<'de> for MapA
 
 struct AttrValueDeserializer(String);
 
-macro_rules! deserialize_type_attr {
-    ($deserialize:ident => $visit:ident) => {
-        fn $deserialize<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
-            visitor.$visit(self.0.parse()?)
-        }
-    };
-}
-
 impl<'de> de::Deserializer<'de> for AttrValueDeserializer {
     type Error = Error;
 
     fn deserialize_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
         visitor.visit_string(self.0)
     }
 
-    deserialize_type_attr!(deserialize_i8 => visit_i8);
-    deserialize_type_attr!(deserialize_i16 => visit_i16);
-    deserialize_type_attr!(deserialize_i32 => visit_i32);
-    deserialize_type_attr!(deserialize_i64 => visit_i64);
-    deserialize_type_attr!(deserialize_u8 => visit_u8);
-    deserialize_type_attr!(deserialize_u16 => visit_u16);
-    deserialize_type_attr!(deserialize_u32 => visit_u32);
-    deserialize_type_attr!(deserialize_u64 => visit_u64);
-    deserialize_type_attr!(deserialize_f32 => visit_f32);
-    deserialize_type_attr!(deserialize_f64 => visit_f64);
+    deserialize_type_attr! { i8, i16, i32, i64, u8, u16, u32, u64, f32, f64 }
 
     fn deserialize_enum<V: de::Visitor<'de>>(
         self,

src/de/mod.rs

@@ -1,6 +1,7 @@
 use std::{io::Read, marker::PhantomData};
 
 use log::trace;
+use paste::paste;
 use serde::de::{self, Unexpected};
 use serde::forward_to_deserialize_any;
 use xml::name::OwnedName;
@@ -235,15 +236,6 @@ impl<'de, R: Read, B: BufferedXmlReader<R>> Deserializer<R, B> {
     }
 }
 
-macro_rules! deserialize_type {
-    ($deserialize:ident => $visit:ident) => {
-        fn $deserialize<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
-            let value = self.prepare_parse_type::<V>()?.parse()?;
-            visitor.$visit(value)
-        }
-    };
-}
-
 impl<'de, 'a, R: Read, B: BufferedXmlReader<R>> de::Deserializer<'de>
     for &'a mut Deserializer<R, B>
 {
@@ -271,16 +263,7 @@ impl<'de, 'a, R: Read, B: BufferedXmlReader<R>> de::Deserializer<'de>
         })
     }
 
-    deserialize_type!(deserialize_i8 => visit_i8);
-    deserialize_type!(deserialize_i16 => visit_i16);
-    deserialize_type!(deserialize_i32 => visit_i32);
-    deserialize_type!(deserialize_i64 => visit_i64);
-    deserialize_type!(deserialize_u8 => visit_u8);
-    deserialize_type!(deserialize_u16 => visit_u16);
-    deserialize_type!(deserialize_u32 => visit_u32);
-    deserialize_type!(deserialize_u64 => visit_u64);
-    deserialize_type!(deserialize_f32 => visit_f32);
-    deserialize_type!(deserialize_f64 => visit_f64);
+    deserialize_type! {i8, i16, i32, i64, u8, u16, u32, u64, f32, f64}
 
     fn deserialize_bool<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
         if let XmlEvent::StartElement { .. } = *self.peek()? {

src/lib.rs

@@ -184,6 +184,8 @@
 //! ```
 //!
 
+#[macro_use]
+mod macros;
 pub mod de;
 mod error;
 pub mod ser;

src/macros.rs

@@ -0,0 +1,56 @@
+#[macro_export]
+macro_rules! serialize_integers {
+    ($($type_suffix:expr), *) => {
+        paste! {
+            $(
+                #[inline]
+                fn [<serialize_i $type_suffix>](self, value: [<i $type_suffix>]) -> Result<Self::Ok>
+                {
+                    let mut buffer = itoa::Buffer::new();
+                    let s = buffer.format(value);
+                    self.serialize_str(s)
+                }
+
+                #[inline]
+                fn [<serialize_u $type_suffix>](self, value: [<u $type_suffix>]) -> Result<Self::Ok>
+                {
+                    let must_close_tag = self.build_start_tag()?;
+                    let mut buffer = itoa::Buffer::new();
+                    let s = buffer.format(value);
+                    self.characters(s)?;
+                    if must_close_tag {
+                        self.end_tag()?;
+                    }
+                    Ok(())
+                }
+            )*
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! deserialize_type_attr {
+    ($($type:ty), *) => {
+        paste! {
+            $(
+                fn [<deserialize_ $type>]<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
+                    visitor.[<visit_ $type>](self.0.parse()?)
+                }
+            )*
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! deserialize_type {
+    ($($type:ty), *) => {
+        paste! {
+            $(
+                fn [<deserialize_ $type>]<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
+                    let value = self.prepare_parse_type::<V>()?.parse()?;
+                    visitor.[<visit_ $type>](value)
+                }
+            )*
+        }
+    };
+}

src/ser/mod.rs

@@ -10,8 +10,9 @@ use self::{
 };
 use crate::error::{Error, Result};
 use log::debug;
+use paste::paste;
 use serde::ser::Serialize;
-use std::{collections::HashMap, io::Write};
+use std::{collections::HashMap, io::Write, str::from_utf8_unchecked};
 use xml::writer::{EmitterConfig, EventWriter, XmlEvent};
 
 /// A convenience method for serializing some object to a buffer.
@@ -194,59 +195,41 @@ impl<'ser, W: Write> serde::ser::Serializer for &'ser mut Serializer<W> {
     type SerializeStruct = StructSerializer<'ser, W>;
     type SerializeStructVariant = StructSerializer<'ser, W>;
 
+    #[inline]
     fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
-        self.serialize_str(&v.to_string())
-    }
-
-    fn serialize_i8(self, v: i8) -> Result<Self::Ok> {
-        self.serialize_i64(i64::from(v))
-    }
-
-    fn serialize_i16(self, v: i16) -> Result<Self::Ok> {
-        self.serialize_i64(i64::from(v))
-    }
-
-    fn serialize_i32(self, v: i32) -> Result<Self::Ok> {
-        self.serialize_i64(i64::from(v))
-    }
-
-    fn serialize_i64(self, v: i64) -> Result<Self::Ok> {
-        self.serialize_str(&v.to_string())
-    }
-
-    fn serialize_u8(self, v: u8) -> Result<Self::Ok> {
-        self.serialize_u64(u64::from(v))
-    }
-
-    fn serialize_u16(self, v: u16) -> Result<Self::Ok> {
-        self.serialize_u64(u64::from(v))
-    }
-
-    fn serialize_u32(self, v: u32) -> Result<Self::Ok> {
-        self.serialize_u64(u64::from(v))
+        let s = if v {
+            b"true" as &[u8]
+        } else {
+            b"false" as &[u8]
+        };
+        self.serialize_bytes(s)
     }
 
-    fn serialize_u64(self, v: u64) -> Result<Self::Ok> {
-        let must_close_tag = self.build_start_tag()?;
-        self.characters(&v.to_string())?;
-        if must_close_tag {
-            self.end_tag()?;
-        }
-        Ok(())
-    }
+    // some magic macros to short the code, could improve when concat_idents stable
+    serialize_integers! {8, 16, 32, 64}
 
+    #[inline]
     fn serialize_f32(self, v: f32) -> Result<Self::Ok> {
-        self.serialize_f64(f64::from(v))
+        let mut buffer = ryu::Buffer::new();
+        let s = buffer.format_finite(v);
+        self.serialize_str(s)
     }
 
+    #[inline]
     fn serialize_f64(self, v: f64) -> Result<Self::Ok> {
-        self.serialize_str(&v.to_string())
+        let mut buffer = ryu::Buffer::new();
+        let s = buffer.format_finite(v);
+        self.serialize_str(s)
     }
 
+    #[inline]
     fn serialize_char(self, v: char) -> Result<Self::Ok> {
-        self.serialize_str(&v.to_string())
+        // A char encoded as UTF-8 takes 4 bytes at most.
+        let mut buf = [0; 4];
+        self.serialize_str(v.encode_utf8(&mut buf))
     }
 
+    #[inline]
     fn serialize_str(self, v: &str) -> Result<Self::Ok> {
         let must_close_tag = self.build_start_tag()?;
         self.characters(v)?;
@@ -256,8 +239,11 @@ impl<'ser, W: Write> serde::ser::Serializer for &'ser mut Serializer<W> {
         Ok(())
     }
 
-    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok> {
-        unimplemented!()
+    #[inline]
+    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok> {
+        // UTF-8 parsing error should be handled by crate users
+        let s = unsafe { from_utf8_unchecked(v) };
+        self.serialize_str(s)
     }
 
     fn serialize_none(self) -> Result<Self::Ok> {