fast-xml -- successor of [quick-xml]

High performance xml pull reader/writer.

The reader: - is almost zero-copy (use of Cow whenever possible) - is easy on memory allocation (the API provides a way to reuse buffers) - support various encoding (with encoding feature), namespaces resolution, special characters.

docs.rs

Syntax is inspired by xml-rs.

Migration from [quick-xml]

If you using quick-xml 0.22.0 or 0.23.0-alpha3, you can just replace quick-xml in your Cargo.toml with fast-xml. Replace each occurrence of quick_xml crate name to fast_xml in your code base.

That two releases of fast-xml was specifically made for migration and contains the same code as original quick-xml, except updated cargo metadata and extern crate names in tests, benches and examples.

Example

Reader

```rust use fastxml::Reader; use fastxml::events::Event;

let xml = r#" Test Test 2 "#;

let mut reader = Reader::fromstr(xml); reader.trimtext(true);

let mut count = 0; let mut txt = Vec::new(); let mut buf = Vec::new();

// The Reader does not implement Iterator because it outputs borrowed data (Cows) loop { // NOTE: this is the generic case when we don't know about the input BufRead. // when the input is a &str or a &[u8], we don't actually need to use another // buffer, we could directly call reader.read_event_unbuffered() match reader.readevent(&mut buf) { Ok(Event::Start(ref e)) => { match e.name() { b"tag1" => println!("attributes values: {:?}", e.attributes().map(|a| a.unwrap().value).collect::>()), b"tag2" => count += 1, _ => (), } }, Ok(Event::Text(e)) => txt.push(e.unescapeanddecode(&reader).unwrap()), Ok(Event::Eof) => break, // exits the loop when reaching end of file Err(e) => panic!("Error at position {}: {:?}", reader.bufferposition(), e), _ => (), // There are several other Events we do not consider here }

// if we don't keep a borrow elsewhere, we can clear the buffer to keep memory usage low
buf.clear();

} ```

Writer

```rust use fastxml::Writer; use fastxml::Reader; use fast_xml::events::{Event, BytesEnd, BytesStart}; use std::io::Cursor; use std::iter;

let xml = r#"text"#; let mut reader = Reader::fromstr(xml); reader.trimtext(true); let mut writer = Writer::new(Cursor::new(Vec::new())); let mut buf = Vec::new(); loop { match reader.readevent(&mut buf) { Ok(Event::Start(ref e)) if e.name() == b"thistag" => {

        // crates a new element ... alternatively we could reuse `e` by calling
        // `e.into_owned()`
        let mut elem = BytesStart::owned(b"my_elem".to_vec(), "my_elem".len());

        // collect existing attributes
        elem.extend_attributes(e.attributes().map(|attr| attr.unwrap()));

        // copy existing attributes, adds a new my-key="some value" attribute
        elem.push_attribute(("my-key", "some value"));

        // writes the event to the writer
        assert!(writer.write_event(Event::Start(elem)).is_ok());
    },
    Ok(Event::End(ref e)) if e.name() == b"this_tag" => {
        assert!(writer.write_event(Event::End(BytesEnd::borrowed(b"my_elem"))).is_ok());
    },
    Ok(Event::Eof) => break,
// you can use either `e` or `&e` if you don't want to move the event
    Ok(e) => assert!(writer.write_event(&e).is_ok()),
    Err(e) => panic!("Error at position {}: {:?}", reader.buffer_position(), e),
}
buf.clear();

}

let result = writer.intoinner().intoinner(); let expected = r#"text"#; asserteq!(result, expected.asbytes()); ```

Serde

When using the serialize feature, fast-xml can be used with serde's Serialize/Deserialize traits.

Here is an example deserializing crates.io source:

```rust // Cargo.toml // [dependencies] // serde = { version = "1.0", features = [ "derive" ] } // fast-xml = { version = "0.22", features = [ "serialize" ] } extern crate serde; extern crate fast_xml;

use serde::Deserialize; use fastxml::de::{fromstr, DeError};

[derive(Debug, Deserialize, PartialEq)]

struct Link { rel: String, href: String, sizes: Option, }

[derive(Debug, Deserialize, PartialEq)]

[serde(rename_all = "lowercase")]

enum Lang { En, Fr, De, }

[derive(Debug, Deserialize, PartialEq)]

struct Head { title: String, #[serde(rename = "link", default)] links: Vec, }

[derive(Debug, Deserialize, PartialEq)]

struct Script { src: String, integrity: String, }

[derive(Debug, Deserialize, PartialEq)]

struct Body { #[serde(rename = "script", default)] scripts: Vec