WIP: stream parsingHEADmain

2 files changed, 45 insertions, 12 deletions

diff --git a/src/element.rs b/src/element.rs
index 4dcb616..35d73a3 100644
--- a/src/element.rs
+++ b/src/element.rs
@@ -9,7 +9,7 @@ pub struct Namespace {
     namespace: String,
 }
 
-// names are qualified, they contain the namespace
+// names are qualified, they contain a reference to the namespace (held within the reader/writer)
 pub struct Name {
     namespace: String,
     name: String,
@@ -22,27 +22,27 @@ pub enum Node {
 
 // should this be a trait?
 pub struct Element {
-    name: Name,
+    pub name: Name,
     // namespace: Name,
     // each element once created contains the qualified namespace information for that element
     // the name contains the qualified namespace so this is unnecessary
     // namespace: String,
     // hashmap of explicit namespace declarations on the element itself only
     // possibly not needed as can be calculated at write time depending on context and qualified namespace, and for reading, element validity and namespaces are kept track of by the reader.
-    namespaces: HashMap<Option<String>, String>,
+    pub namespace_decl: HashMap<Option<String>, String>,
     // attributes can be in a different namespace than the element. how to make sure they are valid?
     // maybe include the namespace instead of or with the prefix
     // you can calculate the prefix from the namespaced name and the current writer context
     // you can validate the prefix and calculate the namespace from the current reader context
     // this results in readers and writers being able to return qualification errors as they aren't able to create elements until every part is qualified.
-    attributes: HashMap<Name, String>,
-    children: Option<Vec<Node>>,
+    pub attributes: HashMap<Name, String>,
+    pub children: Option<Vec<Node>>,
 }
 
 // example of deriving an element:
 
 // #[derive(XMLWrite, XMLRead)]
-// #[peanuts(namespace = "jabber:client", namespace:stream = "http://etherx.jabber.org/streams", name = "stream:stream")]
+// #[peanuts(xmlns = "jabber:client", xmlns:stream = "http://etherx.jabber.org/streams", prefix = "stream")]
 // pub struct Stream {
 //     from: JID,
 //     id: String,
diff --git a/src/reader.rs b/src/reader.rs
index 2785c88..b0d21db 100644
--- a/src/reader.rs
+++ b/src/reader.rs
@@ -1,6 +1,6 @@
 use futures::Stream;
 use nom::Err;
-use std::str;
+use std::{collections::BTreeMap, str};
 use tokio::io::AsyncBufReadExt;
 
 use crate::{
@@ -30,8 +30,8 @@ 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> {
+    /// 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 {
@@ -45,15 +45,48 @@ where
                 }
                 Err(e) => match e {
                     Err::Incomplete(_) => (),
-                    e => return Err(Error::ParseError(input.to_owned())),
+                    e => return Err::<E, Error>(Error::ParseError(input.to_owned())),
                 },
             }
         }
-        self.inner.consume(len);
 
-        // Ok(element)
+        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!()
     // }