path: root/src/reader.rs

use futures::Stream;
use nom::Err;
use std::{collections::BTreeMap, 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,
{
    /// could resursively read and include namespace tree with values to be shadowed within new local context
    async fn read_recursive(&mut self, namespaces: BTreeMap<Option<String>, String>) -> Result<Element, 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::<E, Error>(Error::ParseError(input.to_owned())),
                },
            }
        }

        let final;
        match element {
            crate::xml::Element::Empty(e) => {
                let final = Element {
                    
                }
            },
            crate::xml::Element::NotEmpty(_, _, _) => todo!(),
        }

        self.inner.consume(len);
        todo!()
    }
    /// reads entire next prolog, element, or misc
    // pub async fn read<E: From<Element>>(&mut self) -> Result<E, 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::<E, Error>(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!()
//     }
// }