Merge pull request #681 from adamreichold/key-buf

RFC: Re-use a long-lived buffer for prefixing attribute names.

Author: Mingun

src/de/key.rs

@@ -76,17 +76,25 @@ pub struct QNameDeserializer<'i, 'd> {
 
 impl<'i, 'd> QNameDeserializer<'i, 'd> {
     /// Creates deserializer from name of an attribute
-    pub fn from_attr(name: QName<'d>, decoder: Decoder) -> Result<Self, DeError> {
+    pub fn from_attr(
+        name: QName<'d>,
+        decoder: Decoder,
+        key_buf: &'d mut String,
+    ) -> Result<Self, DeError> {
+        key_buf.clear();
+        key_buf.push('@');
+
         // https://github.com/tafia/quick-xml/issues/537
         // Namespace bindings (xmlns:xxx) map to `@xmlns:xxx` instead of `@xxx`
-        let field = if name.as_namespace_binding().is_some() {
-            decoder.decode(name.into_inner())?
+        if name.as_namespace_binding().is_some() {
+            decoder.decode_into(name.into_inner(), key_buf)?;
         } else {
-            decode_name(name, decoder)?
+            let local = name.local_name();
+            decoder.decode_into(local.into_inner(), key_buf)?;
         };
 
         Ok(Self {
-            name: CowRef::Owned(format!("@{field}")),
+            name: CowRef::Slice(key_buf),
         })
     }
 

src/de/map.rs

@@ -238,7 +238,8 @@ where
             let (key, value) = a.into();
             self.source = ValueSource::Attribute(value.unwrap_or_default());
 
-            let de = QNameDeserializer::from_attr(QName(&slice[key]), decoder)?;
+            let de =
+                QNameDeserializer::from_attr(QName(&slice[key]), decoder, &mut self.de.key_buf)?;
             seed.deserialize(de).map(Some)
         } else {
             // try getting from events (<key>value</key>)

src/de/mod.rs

@@ -2376,6 +2376,9 @@ where
 
     #[cfg(not(feature = "overlapped-lists"))]
     peek: Option<DeEvent<'de>>,
+
+    /// Buffer to store attribute name as a field name exposed to serde consumers
+    key_buf: String,
 }
 
 impl<'de, R, E> Deserializer<'de, R, E>
@@ -2402,6 +2405,8 @@ where
 
             #[cfg(not(feature = "overlapped-lists"))]
             peek: None,
+
+            key_buf: String::new(),
         }
     }
 

src/encoding.rs

@@ -3,7 +3,7 @@
 use std::borrow::Cow;
 
 #[cfg(feature = "encoding")]
-use encoding_rs::{Encoding, UTF_16BE, UTF_16LE, UTF_8};
+use encoding_rs::{DecoderResult, Encoding, UTF_16BE, UTF_16LE, UTF_8};
 
 #[cfg(feature = "encoding")]
 use crate::Error;
@@ -88,6 +88,17 @@ impl Decoder {
 
         decoded
     }
+
+    /// Like [`decode`][Self::decode] but using a pre-allocated buffer.
+    pub fn decode_into(&self, bytes: &[u8], buf: &mut String) -> Result<()> {
+        #[cfg(not(feature = "encoding"))]
+        buf.push_str(std::str::from_utf8(bytes)?);
+
+        #[cfg(feature = "encoding")]
+        decode_into(bytes, self.encoding, buf)?;
+
+        Ok(())
+    }
 }
 
 /// Decodes the provided bytes using the specified encoding.
@@ -100,6 +111,34 @@ pub fn decode<'b>(bytes: &'b [u8], encoding: &'static Encoding) -> Result<Cow<'b
         .ok_or(Error::NonDecodable(None))
 }
 
+/// Like [`decode`] but using a pre-allocated buffer.
+#[cfg(feature = "encoding")]
+pub fn decode_into(bytes: &[u8], encoding: &'static Encoding, buf: &mut String) -> Result<()> {
+    if encoding == UTF_8 {
+        buf.push_str(std::str::from_utf8(bytes)?);
+        return Ok(());
+    }
+
+    let mut decoder = encoding.new_decoder_without_bom_handling();
+    buf.reserve(
+        decoder
+            .max_utf8_buffer_length_without_replacement(bytes.len())
+            // SAFETY: None can be returned only if required size will overflow usize,
+            // but in that case String::reserve also panics
+            .unwrap(),
+    );
+    let (result, read) = decoder.decode_to_string_without_replacement(bytes, buf, true);
+    match result {
+        DecoderResult::InputEmpty => {
+            debug_assert_eq!(read, bytes.len());
+            Ok(())
+        }
+        DecoderResult::Malformed(_, _) => Err(Error::NonDecodable(None)),
+        // SAFETY: We allocate enough space above
+        DecoderResult::OutputFull => unreachable!(),
+    }
+}
+
 /// Automatic encoding detection of XML files based using the
 /// [recommended algorithm](https://www.w3.org/TR/xml11/#sec-guessing).
 ///