Have read_namespace_event borrow the ns buffer

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "quick-xml"
-version = "0.7.3"
+version = "0.8.0"
 authors = ["Johann Tuffe <tafia973@gmail.com>"]
 description = "High performance xml reader and writer"
 
@@ -16,11 +16,11 @@ license-file = "LICENSE-MIT.md"
 travis-ci = { repository = "tafia/quick-xml" }
 
 [dependencies]
-encoding_rs = "0.6.6"
+encoding_rs = "0.6.11"
 error-chain = "0.10.0"
 
 [dev-dependencies]
-xml-rs = "0.4.1"
+xml-rs = "0.6.0"
 
 [lib]
 bench = false

Changelog.md

@@ -8,6 +8,10 @@
   - test: Adding missing tests
   - chore: Changes to the build process or auxiliary tools/libraries/documentation
 
+## 0.8.0
+- fix: make the reader borrow the namespace buffer so it can be used repetitively
+- refactor: bump dependencies
+
 ## 0.7.3
 - fix: fix Event::Text slice always starting at the beginning of the buffer
 

README.md

@@ -18,7 +18,7 @@ Syntax is inspired by [xml-rs](https://github.com/netvl/xml-rs).
 
 ```toml
 [dependencies]
-quick-xml = "0.7.0"
+quick-xml = "0.8.0"
 ```
 ``` rust
 extern crate quick_xml;
@@ -49,11 +49,7 @@ let mut buf = Vec::new();
 // The `Reader` does not implement `Iterator` because it outputs borrowed data (`Cow`s)
 loop {
     match reader.read_event(&mut buf) {
-    // for triggering namespaced events, use this instead:
-    // match reader.read_namespaced_event(&mut buf) {
         Ok(Event::Start(ref e)) => {
-        // for namespaced:
-        // Ok((ref namespace_value, Event::Start(ref e)))
             match e.name() {
                 b"tag1" => println!("attributes values: {:?}",
                                     e.attributes().map(|a| a.unwrap().value).collect::<Vec<_>>()),

benches/bench.rs

@@ -36,8 +36,9 @@ fn bench_quick_xml_namespaced(b: &mut Bencher) {
         r.check_end_names(false).check_comments(false);
         let mut count = test::black_box(0);
         let mut buf = Vec::new();
+        let mut ns_buf = Vec::new();
         loop {
-            match r.read_namespaced_event(&mut buf) {
+            match r.read_namespaced_event(&mut buf, &mut ns_buf) {
                 Ok((_, Event::Start(_))) |
                 Ok((_, Event::Empty(_))) => count += 1,
                 Ok((_, Event::Eof)) => break,

examples/issue68.rs

@@ -0,0 +1,143 @@
+#![allow(unused)]
+
+extern crate quick_xml;
+
+use quick_xml::reader::Reader;
+use quick_xml::events::Event;
+use std::io::Read;
+
+struct Resource {
+    etag: String,
+    calendar_data: String,
+}
+
+struct Prop {
+    namespace: String,
+    local_name: String,
+    value: String,
+}
+
+impl Prop {
+    fn new() -> Prop {
+        Prop {
+            namespace: String::new(),
+            local_name: String::new(),
+            value: String::new(),
+        }
+    }
+}
+
+struct PropStat {
+    status: String,
+    props: Vec<Prop>,
+}
+
+impl PropStat {
+    fn new() -> PropStat {
+        PropStat {
+            status: String::new(),
+            props: Vec::<Prop>::new(),
+        }
+    }
+}
+
+struct Response {
+    href: String,
+    propstats: Vec<PropStat>,
+}
+
+impl Response {
+    fn new() -> Response {
+        Response {
+            href: String::new(),
+            propstats: Vec::<PropStat>::new(),
+        }
+    }
+}
+
+fn parse_report(xml_data: &str) -> Vec<Resource> {
+    let result = Vec::<Resource>::new();
+
+    let mut reader = Reader::from_str(xml_data);
+    reader.trim_text(true);
+
+    let mut count = 0;
+    let mut buf = Vec::new();
+    let mut ns_buffer = Vec::new();
+
+    #[derive(Clone, Copy)]
+    enum State {
+        Root,
+        MultiStatus,
+        Response,
+        Success,
+        Error,
+    };
+
+    let mut responses = Vec::<Response>::new();
+    let mut current_response = Response::new();
+    let mut current_prop = Prop::new();
+
+    let mut depth = 0;
+    let mut state = State::MultiStatus;
+
+    loop {
+
+        match reader.read_namespaced_event(&mut buf, &mut ns_buffer) {
+            Ok((namespace_value, Event::Start(e))) => {
+                let namespace_value = namespace_value.unwrap_or_default();
+                match (depth, state, namespace_value, e.local_name()) {
+                    (0, State::Root, b"DAV:", b"multistatus") => state = State::MultiStatus,
+                    (1, State::MultiStatus, b"DAV:", b"response") => {
+                        state = State::Response;
+                        current_response = Response::new();
+                    }
+                    (2, State::Response, b"DAV:", b"href") => {
+                        current_response.href = e.unescape_and_decode(&reader).unwrap();
+                    }
+                    _ => {}
+                }
+                depth += 1;
+            }
+            Ok((namespace_value, Event::End(e))) => {
+                let namespace_value = namespace_value.unwrap_or_default();
+                let local_name = e.local_name();
+                match (depth, state, &*namespace_value, local_name) {
+                    (1, State::MultiStatus, b"DAV:", b"multistatus") => state = State::Root,
+                    (2, State::MultiStatus, b"DAV:", b"multistatus") => state = State::MultiStatus,
+                    _ => {}
+                }
+                depth -= 1;
+            }
+            Ok((_, Event::Eof)) => break,
+            Err(e) => break,
+            _ => (),
+        }
+
+    }
+    result
+}
+
+fn main() {
+    let test_data = r#"
+<?xml version="1.0" encoding="UTF-8"?>
+<D:multistatus xmlns:D="DAV:" xmlns:caldav="urn:ietf:params:xml:ns:caldav"
+    xmlns:cs="http://calendarserver.org/ns/" xmlns:ical="http://apple.com/ns/ical/">
+ <D:response xmlns:carddav="urn:ietf:params:xml:ns:carddav"
+    xmlns:cm="http://cal.me.com/_namespace/" xmlns:md="urn:mobileme:davservices">
+  <D:href>
+  /caldav/v2/johndoh%40gmail.com/events/07b7it7uonpnlnvjldr0l1ckg8%40google.com.ics
+  </D:href>
+  <D:propstat>
+   <D:status>HTTP/1.1 200 OK</D:status>
+   <D:prop>
+    <D:getetag>"63576798396"</D:getetag>
+    <caldav:calendar-data>BEGIN:VCALENDAR</caldav:calendar-data>
+   </D:prop>
+  </D:propstat>
+ </D:response>
+</D:multistatus>
+"#;
+
+    parse_report(test_data);
+}

src/events/mod.rs

@@ -157,7 +157,7 @@ impl<'a> BytesDecl<'a> {
             Some(Ok(a)) => {
                 Err(format!("XmlDecl must start with 'version' attribute, found {:?}",
                             from_utf8(a.key))
-                            .into())
+                        .into())
             }
             None => Err("XmlDecl must start with 'version' attribute, found none".into()),
         }
@@ -406,8 +406,7 @@ fn local_name() {
     let mut buf = Vec::new();
     let mut parsed_local_names = Vec::new();
     loop {
-        match rdr.read_event(&mut buf)
-                  .expect("unable to read xml event") {
+        match rdr.read_event(&mut buf).expect("unable to read xml event") {
             Event::Start(ref e) => {
                 parsed_local_names.push(from_utf8(e.local_name())
                                             .expect("unable to build str from local_name")