peanuts/src/reader.rs

use futures::Stream;
use nom::Err;
use std::str;
use tokio::io::AsyncBufReadExt;

use crate::{
    element::{Element, Name, Namespace},
    error::Error,
};

/// streaming reader that tracks depth and available namespaces at current depth
pub struct Reader<R> {
    inner: R,
    // holds which tags we are in atm over depth
    depth: Vec<Name>,
    namespaces: Vec<(usize, Namespace)>,
}

impl<R> Reader<R> {
    pub fn new(reader: R) -> Self {
        Self {
            inner: reader,
            depth: Vec::new(),
            namespaces: Vec::new(),
        }
    }
}

impl<R> Reader<R>
where
    R: AsyncBufReadExt + Unpin,
{
    /// reads entire next prolog, element, or misc
    pub async fn read<'s>(&'s mut self) -> Result<crate::xml::Element<'s>, Error> {
        let element;
        let len;
        loop {
            let buf = self.inner.fill_buf().await?;
            let input = str::from_utf8(buf)?;
            match crate::xml::element(input) {
                Ok((rest, e)) => {
                    element = e;
                    len = buf.len() - rest.len();
                    break;
                }
                Err(e) => match e {
                    Err::Incomplete(_) => (),
                    e => return Err(Error::ParseError(input.to_owned())),
                },
            }
        }
        self.inner.consume(len);

        // Ok(element)
        todo!()
    }
    // pub async fn read_start(&self) -> Result<impl From<Element>, Error> {
    //     todo!()
    // }
    // pub async fn read_end(&self) -> Result<(), Error> {
    //     todo!()
    // }
}

// impl<R: AsyncBufRead> Stream for Reader<R> {
//     type Item = impl From<Element>;

//     async fn poll_next(
//         self: std::pin::Pin<&mut Self>,
//         cx: &mut std::task::Context<'_>,
//     ) -> std::task::Poll<Option<Self::Item>> {
//         todo!()
//     }
// }