From e762babd9e69400ccd178ba8946168640093eb63 Mon Sep 17 00:00:00 2001
From: HampusM <hampus@hampusmat.com>
Date: Sat, 15 Apr 2023 18:26:29 +0200
Subject: feat: add deserialization

---
 src/deserializer/buffered.rs | 212 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 212 insertions(+)
 create mode 100644 src/deserializer/buffered.rs

(limited to 'src/deserializer/buffered.rs')

diff --git a/src/deserializer/buffered.rs b/src/deserializer/buffered.rs
new file mode 100644
index 0000000..7a6058b
--- /dev/null
+++ b/src/deserializer/buffered.rs
@@ -0,0 +1,212 @@
+//! Buffered XML deserializer.
+use std::convert::Infallible;
+use std::io::BufRead;
+
+use quick_xml::events::Event;
+use quick_xml::Reader;
+
+use crate::deserializer::{Deserializer, Error, IgnoreEnd};
+use crate::event::EventExt;
+use crate::tagged::TagStart;
+use crate::DeserializeTagged;
+
+/// XML deserializer using a source which has an internal buffer.
+pub struct Buffered<Source: BufRead>
+{
+    reader: Reader<Source>,
+    leftover_event: Option<Event<'static>>,
+    buf: Vec<u8>,
+}
+
+impl<Source> Buffered<Source>
+where
+    Source: BufRead,
+{
+    /// Returns a new [`Buffered`].
+    pub fn new(source: Source) -> Self
+    {
+        let mut reader = Reader::from_reader(source);
+
+        reader.trim_text(true);
+        reader.expand_empty_elements(true);
+
+        Self {
+            reader,
+            leftover_event: None,
+            buf: Vec::new(),
+        }
+    }
+}
+
+impl<Source> Deserializer for Buffered<Source>
+where
+    Source: BufRead,
+{
+    fn de_tag<De: DeserializeTagged>(
+        &mut self,
+        tag_name: &str,
+        ignore_end: IgnoreEnd,
+    ) -> Result<De, Error<De::Error>>
+    {
+        self.de_tag_with(tag_name, ignore_end, De::deserialize)
+    }
+
+    fn de_tag_with<Output, Err, DeserializeFn>(
+        &mut self,
+        tag_name: &str,
+        ignore_end: IgnoreEnd,
+        deserialize: DeserializeFn,
+    ) -> Result<Output, Error<Err>>
+    where
+        Err: std::error::Error + Send + Sync + 'static,
+        DeserializeFn: FnOnce(&TagStart, &mut Self) -> Result<Output, Err>,
+    {
+        let deserialized = match self.read_event()? {
+            Event::Start(start) if start.name().as_ref() == tag_name.as_bytes() => {
+                deserialize(&TagStart::from_inner(start), self)
+                    .map_err(Error::DeserializeFailed)?
+            }
+            event => {
+                self.leftover_event = Some(event.clone().into_owned());
+
+                return Err(Error::UnexpectedEvent {
+                    expected_event_name: format!("start({tag_name})"),
+                    found_event: event.describe().unwrap(),
+                });
+            }
+        };
+
+        if let IgnoreEnd::No = ignore_end {
+            self.read_end_event(tag_name.as_bytes())
+                .map_err(Error::into_with_de_error)?;
+        }
+
+        Ok(deserialized)
+    }
+
+    fn de_tag_list<De: DeserializeTagged>(
+        &mut self,
+        tag_name: Option<&str>,
+    ) -> Result<Vec<De>, Error<De::Error>>
+    {
+        let mut deserialized_items = Vec::new();
+
+        loop {
+            let start = match self.read_event()? {
+                Event::Start(start)
+                    if tag_name.map_or_else(
+                        || true,
+                        |expected_tag_name| {
+                            start.name().as_ref() == expected_tag_name.as_bytes()
+                        },
+                    ) =>
+                {
+                    TagStart::from_inner(start)
+                }
+                Event::Comment(_) => {
+                    continue;
+                }
+                event => {
+                    self.leftover_event = Some(event.into_owned());
+                    break;
+                }
+            };
+
+            let deserialized =
+                De::deserialize(&start, self).map_err(Error::DeserializeFailed)?;
+
+            self.read_end_event(start.name())
+                .map_err(Error::into_with_de_error)?;
+
+            deserialized_items.push(deserialized);
+        }
+
+        Ok(deserialized_items)
+    }
+
+    fn de_text(&mut self) -> Result<String, Error<Infallible>>
+    {
+        let text = match self.read_event::<Infallible>()? {
+            Event::Text(text) => Ok(text),
+            event => {
+                self.leftover_event = Some(event.clone().into_owned());
+
+                Err(Error::<Infallible>::UnexpectedEvent {
+                    expected_event_name: "text".to_string(),
+                    found_event: event.describe().unwrap(),
+                })
+            }
+        }?
+        .unescape()
+        .map_err(|err| Error::<Infallible>::XMLError(err.into()))?;
+
+        Ok(text.to_string())
+    }
+
+    fn skip_to_tag_start(&mut self, tag_name: &str) -> Result<(), Error<Infallible>>
+    {
+        loop {
+            match self.read_event::<Infallible>()? {
+                Event::Start(start) if start.name().as_ref() == tag_name.as_bytes() => {
+                    self.leftover_event = Some(Event::Start(start).into_owned());
+
+                    break;
+                }
+                _ => {}
+            }
+        }
+
+        Ok(())
+    }
+
+    fn skip_to_tag_end(&mut self, tag_name: &str) -> Result<(), Error<Infallible>>
+    {
+        loop {
+            match self.read_event::<Infallible>()? {
+                Event::End(end) if end.name().as_ref() == tag_name.as_bytes() => {
+                    self.leftover_event = Some(Event::End(end).into_owned());
+
+                    return Ok(());
+                }
+                _ => {}
+            }
+        }
+    }
+}
+
+impl<Source> Buffered<Source>
+where
+    Source: BufRead,
+{
+    fn read_end_event(&mut self, tag_name: &[u8]) -> Result<(), Error<Infallible>>
+    {
+        let event = self.read_event::<Infallible>()?;
+
+        if matches!(&event, Event::End(end) if end.name().as_ref() == tag_name) {
+            return Ok(());
+        }
+
+        Err(Error::UnexpectedEvent {
+            expected_event_name: "end".to_string(),
+            found_event: event.describe().unwrap(),
+        })
+    }
+
+    fn read_event<DeError>(&mut self) -> Result<Event<'static>, Error<DeError>>
+    {
+        let event = if let Some(leftover_event) = self.leftover_event.take() {
+            leftover_event
+        } else {
+            self.reader
+                .read_event_into(&mut self.buf)
+                .map_err(|err| Error::<DeError>::XMLError(err.into()))?
+                .into_owned()
+        };
+
+        if let Event::Eof = &event {
+            return Err(Error::UnexpectedEndOfFile);
+        }
+
+        Ok(event)
+    }
+}
-- 
cgit v1.2.3-18-g5258