Add zero-copy deserialization

src/de/map.rs

@@ -1,12 +1,11 @@
 //! Serde `Deserializer` module
 
 use crate::{
-    de::{escape::EscapedDeserializer, Deserializer, INNER_VALUE, UNFLATTEN_PREFIX},
+    de::{escape::EscapedDeserializer, BorrowingReader, Deserializer, INNER_VALUE},
     errors::serialize::DeError,
-    events::{attributes::Attribute, BytesStart, Event},
+    events::{BytesStart, Event},
 };
 use serde::de::{self, DeserializeSeed, IntoDeserializer};
-use std::io::BufRead;
 
 enum MapValue {
     Empty,
@@ -16,10 +15,10 @@ enum MapValue {
 }
 
 /// A deserializer for `Attributes`
-pub(crate) struct MapAccess<'a, R: BufRead> {
+pub(crate) struct MapAccess<'de, 'a, R: BorrowingReader<'de> + 'a> {
     /// Tag -- owner of attributes
-    start: BytesStart<'static>,
-    de: &'a mut Deserializer<R>,
+    start: BytesStart<'de>,
+    de: &'a mut Deserializer<'de, R>,
     /// Position in flat byte slice of all attributes from which next
     /// attribute should be parsed. This field is required because we
     /// do not store reference to `Attributes` itself but instead create
@@ -29,9 +28,9 @@ pub(crate) struct MapAccess<'a, R: BufRead> {
     value: MapValue,
 }
 
-impl<'a, R: BufRead> MapAccess<'a, R> {
+impl<'de, 'a, R: BorrowingReader<'de>> MapAccess<'de, 'a, R> {
     /// Create a new MapAccess
-    pub fn new(de: &'a mut Deserializer<R>, start: BytesStart<'static>) -> Result<Self, DeError> {
+    pub fn new(de: &'a mut Deserializer<'de, R>, start: BytesStart<'de>) -> Result<Self, DeError> {
         let position = start.attributes().position;
         Ok(MapAccess {
             de,
@@ -41,29 +40,25 @@ impl<'a, R: BufRead> MapAccess<'a, R> {
         })
     }
 
-    fn next_attr(&mut self) -> Result<Option<Attribute>, DeError> {
+    fn next_attr(&mut self) -> Result<Option<(Vec<u8>, Vec<u8>)>, DeError> {
         let mut attributes = self.start.attributes();
         attributes.position = self.position;
-        let next_att = attributes.next();
+        let next_att = attributes.next().transpose()?;
         self.position = attributes.position;
-        Ok(next_att.transpose()?)
+        Ok(next_att.map(|a| (a.key.to_owned(), a.value.into_owned())))
     }
 }
 
-impl<'a, 'de, R: BufRead> de::MapAccess<'de> for MapAccess<'a, R> {
+impl<'de, 'a, R: BorrowingReader<'de> + 'a> de::MapAccess<'de> for MapAccess<'de, 'a, R> {
     type Error = DeError;
 
     fn next_key_seed<K: DeserializeSeed<'de>>(
         &mut self,
         seed: K,
     ) -> Result<Option<K::Value>, Self::Error> {
-        let attr_key_val = self
-            .next_attr()?
-            .map(|a| (a.key.to_owned(), a.value.into_owned()));
         let decoder = self.de.reader.decoder();
         let has_value_field = self.de.has_value_field;
-        let has_unflatten_field = self.de.has_unflatten_field;
-        if let Some((key, value)) = attr_key_val {
+        if let Some((key, value)) = self.next_attr()? {
             // try getting map from attributes (key= "value")
             self.value = MapValue::Attribute { value };
             seed.deserialize(EscapedDeserializer::new(key, decoder, false))
@@ -97,8 +92,12 @@ impl<'a, 'de, R: BufRead> de::MapAccess<'de> for MapAccess<'a, R> {
                 }
                 Some(Event::Start(e)) if has_unflatten_field => {
                     self.value = MapValue::InnerValue;
-                    let key = format!("{}{}", UNFLATTEN_PREFIX, String::from_utf8(e.local_name().to_vec())
-                                      .expect("$unflatten= did not contain valid Rust identifier"));
+                    let key = format!(
+                        "{}{}",
+                        UNFLATTEN_PREFIX,
+                        String::from_utf8(e.local_name().to_vec())
+                            .expect("$unflatten= did not contain valid Rust identifier")
+                    );
                     seed.deserialize(key.into_deserializer()).map(Some)
                 }
                 Some(Event::Start(e)) => {