Allow to deserialize event names into borrowed fields

Author: Mingun

Changelog.md

@@ -23,6 +23,8 @@
 - [#568]: Rename `Writter::inner` into `Writter::get_mut`
 - [#568]: Add method `Writter::get_ref`
 - [#569]: Rewrite the `Reader::read_event_into_async` as an async fn, making the future `Send` if possible.
+- [#571]: Borrow element names (`<element>`) when deserialize with serde.
+  This change allow to deserialize into `HashMap<&str, T>`, for example
 
 ### Bug Fixes
 
@@ -55,6 +57,7 @@
 [#565]: https://github.com/tafia/quick-xml/pull/565
 [#568]: https://github.com/tafia/quick-xml/pull/568
 [#569]: https://github.com/tafia/quick-xml/pull/569
+[#571]: https://github.com/tafia/quick-xml/pull/571
 
 ## 0.27.1 -- 2022-12-28
 

src/de/key.rs

@@ -90,10 +90,22 @@ impl<'i, 'd> QNameDeserializer<'i, 'd> {
     }
 
     /// Creates deserializer from name of an element
-    pub fn from_elem(name: QName<'d>, decoder: Decoder) -> Result<Self, DeError> {
-        let local = match decode_name(name, decoder)? {
-            Cow::Borrowed(borrowed) => CowRef::Slice(borrowed),
-            Cow::Owned(owned) => CowRef::Owned(owned),
+    pub fn from_elem(name: CowRef<'i, 'd, [u8]>, decoder: Decoder) -> Result<Self, DeError> {
+        let local = match name {
+            CowRef::Input(borrowed) => match decode_name(QName(borrowed), decoder)? {
+                Cow::Borrowed(borrowed) => CowRef::Input(borrowed),
+                Cow::Owned(owned) => CowRef::Owned(owned),
+            },
+            CowRef::Slice(borrowed) => match decode_name(QName(borrowed), decoder)? {
+                Cow::Borrowed(borrowed) => CowRef::Slice(borrowed),
+                Cow::Owned(owned) => CowRef::Owned(owned),
+            },
+            CowRef::Owned(owned) => match decode_name(QName(&owned), decoder)? {
+                // SAFETY: Because result is borrowed, no changes was done
+                // and we can safely unwrap here
+                Cow::Borrowed(_) => CowRef::Owned(String::from_utf8(owned).unwrap()),
+                Cow::Owned(owned) => CowRef::Owned(owned),
+            },
         };
 
         Ok(Self { name: local })

src/de/map.rs

@@ -281,7 +281,7 @@ where
                 DeEvent::Start(e) => {
                     self.source = ValueSource::Nested;
 
-                    let de = QNameDeserializer::from_elem(e.name(), decoder)?;
+                    let de = QNameDeserializer::from_elem(e.raw_name(), decoder)?;
                     seed.deserialize(de).map(Some)
                 }
                 // Stop iteration after reaching a closing tag

src/de/var.rs

@@ -38,7 +38,7 @@ where
         let decoder = self.de.reader.decoder();
         let (name, is_text) = match self.de.peek()? {
             DeEvent::Start(e) => (
-                seed.deserialize(QNameDeserializer::from_elem(e.name(), decoder)?)?,
+                seed.deserialize(QNameDeserializer::from_elem(e.raw_name(), decoder)?)?,
                 false,
             ),
             DeEvent::Text(_) => (

src/events/mod.rs

@@ -49,7 +49,7 @@ use crate::errors::{Error, Result};
 use crate::escape::{escape, partial_escape, unescape_with};
 use crate::name::{LocalName, QName};
 use crate::reader::is_whitespace;
-use crate::utils::write_cow_string;
+use crate::utils::{write_cow_string, CowRef};
 use attributes::{Attribute, Attributes};
 use std::mem::replace;
 
@@ -189,6 +189,21 @@ impl<'a> BytesStart<'a> {
         self.name_len = name.len();
         self
     }
+
+    /// Gets the undecoded raw tag name, as present in the input stream, which
+    /// is borrowed either to the input, or to the event.
+    ///
+    /// # Lifetimes
+    ///
+    /// - `'a`: Lifetime of the input data from which this event is borrow
+    /// - `'e`: Lifetime of the concrete event instance
+    // TODO: We should made this is a part of public API, but with safe wrapped for a name
+    pub(crate) fn raw_name<'e>(&'e self) -> CowRef<'a, 'e, [u8]> {
+        match self.buf {
+            Cow::Borrowed(b) => CowRef::Input(&b[..self.name_len]),
+            Cow::Owned(ref o) => CowRef::Slice(&o[..self.name_len]),
+        }
+    }
 }
 
 /// Attribute-related methods

tests/serde-de.rs

@@ -6285,6 +6285,9 @@ fn from_str_should_ignore_encoding() {
 /// Checks that deserializer is able to borrow data from the input
 mod borrow {
     use super::*;
+    use pretty_assertions::assert_eq;
+    use std::collections::BTreeMap;
+    use std::iter::FromIterator;
 
     /// Struct that should borrow input to be able to deserialize successfully.
     /// serde implicitly borrow `&str` and `&[u8]` even without `#[serde(borrow)]`
@@ -6403,4 +6406,24 @@ mod borrow {
             }
         }
     }
+
+    #[test]
+    fn element_name() {
+        let data: BTreeMap<&str, &str> = from_str(
+            r#"
+            <root>
+                <element>element content</element>
+                text content
+            </root>"#,
+        )
+        .unwrap();
+        assert_eq!(
+            data,
+            BTreeMap::from_iter([
+                // Comment to prevent formatting in one line
+                ("element", "element content"),
+                ("$text", "text content"),
+            ])
+        );
+    }
 }