xsd_parser/quick_xml/reader/
io_reader.rs

1use std::fmt::{Debug, Formatter, Result as FmtResult};
2use std::io::BufRead;
3
4use quick_xml::{
5    events::Event,
6    name::{LocalName, PrefixIter, QName, ResolveResult},
7    NsReader,
8};
9
10#[cfg(feature = "async")]
11use tokio::io::AsyncBufRead;
12
13use super::super::{Error, XmlReader, XmlReaderSync};
14
15/// Implements an [`XmlReader`] for any kind of [`BufRead`].
16pub struct IoReader<R> {
17    inner: NsReader<R>,
18    buffer: Vec<u8>,
19}
20
21impl<R> IoReader<R> {
22    /// Create a new [`IoReader`] instance from the passed `reader`.
23    pub fn new(reader: R) -> Self {
24        let inner = NsReader::from_reader(reader);
25        let buffer = Vec::new();
26
27        Self { inner, buffer }
28    }
29}
30
31impl<R> XmlReader for IoReader<R> {
32    fn resolve<'n>(&self, name: QName<'n>, attribute: bool) -> (ResolveResult<'_>, LocalName<'n>) {
33        self.inner.resolve(name, attribute)
34    }
35
36    fn prefixes(&self) -> PrefixIter<'_> {
37        self.inner.prefixes()
38    }
39
40    fn current_position(&self) -> u64 {
41        self.inner.buffer_position()
42    }
43
44    fn error_position(&self) -> u64 {
45        self.inner.error_position()
46    }
47}
48
49impl<R> XmlReaderSync<'static> for IoReader<R>
50where
51    R: BufRead,
52{
53    fn read_event(&mut self) -> Result<Event<'static>, Error> {
54        self.inner
55            .read_event_into(&mut self.buffer)
56            .map(Event::into_owned)
57            .map_err(|error| self.map_error(error))
58    }
59}
60
61#[cfg(feature = "async")]
62impl<R> super::super::XmlReaderAsync<'static> for IoReader<R>
63where
64    R: AsyncBufRead + Unpin,
65{
66    type ReadEventFut<'x>
67        = std::pin::Pin<Box<dyn std::future::Future<Output = Result<Event<'static>, Error>> + 'x>>
68    where
69        Self: 'x;
70
71    fn read_event_async(&mut self) -> Self::ReadEventFut<'_> {
72        Box::pin(async move {
73            match self.inner.read_event_into_async(&mut self.buffer).await {
74                Ok(event) => Ok(event.into_owned()),
75                Err(error) => Err(self.map_error(error)),
76            }
77        })
78    }
79}
80
81impl<R> Debug for IoReader<R> {
82    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
83        write!(f, "IoReader")
84    }
85}