Struct ElementBuilder

pub struct ElementBuilder { /* private fields */ }

An Element Builder, building Elements from Events as produced by Parser

use xml::{Parser, ElementBuilder};

let mut parser = Parser::new();
let mut builder = ElementBuilder::new();

parser.feed_str("<example/>");
for result in parser.filter_map(|event| builder.handle_event(event)) {
    println!("{}", result.unwrap());
}

Implementations

impl ElementBuilder

pub fn new() -> ElementBuilder

Returns a new ElementBuilder

Examples found in repository

examples/roundtrip.rs (line 33)

fn main() {
    let mut args = std::env::args();
    let name = args.next().unwrap_or_else(|| "roundtrip".to_string());
    let path = args.next();
    let path = if let Some(ref path) = path {
        path
    } else {
        println!("Usage: {} <file>", name);
        return;
    };
    let mut rdr = match File::open(path) {
        Ok(file) => file,
        Err(err) => {
            println!("Couldn't open file: {}", err);
            std::process::exit(1);
        }
    };

    let mut p = xml::Parser::new();
    let mut e = xml::ElementBuilder::new();

    let mut string = String::new();
    if let Err(err) = rdr.read_to_string(&mut string) {
        println!("Reading failed: {}", err);
        std::process::exit(1);
    };

    p.feed_str(&string);
    for event in p.filter_map(|x| e.handle_event(x)) {
        // println!("{:?}", event);
        match event {
            Ok(e) => println!("{}", e),
            Err(e) => println!("{}", e),
        }
    }
}

pub fn define_prefix(&mut self, prefix: String, ns: String)

Bind a prefix to a namespace

pub fn set_default_ns(&mut self, ns: String)

Set the default namespace

pub fn handle_event( &mut self, e: Result<Event, ParserError>, ) -> Option<Result<Element, BuilderError>>

Let the builder process an Event to ultimately build an Element.

While no root element has been finished None is returned. Once sufficient data has been received an Element is returned as Some(Ok(elem)). Upon Error Some(Err("message")) is returned.

Examples found in repository

examples/roundtrip.rs (line 42)

fn main() {
    let mut args = std::env::args();
    let name = args.next().unwrap_or_else(|| "roundtrip".to_string());
    let path = args.next();
    let path = if let Some(ref path) = path {
        path
    } else {
        println!("Usage: {} <file>", name);
        return;
    };
    let mut rdr = match File::open(path) {
        Ok(file) => file,
        Err(err) => {
            println!("Couldn't open file: {}", err);
            std::process::exit(1);
        }
    };

    let mut p = xml::Parser::new();
    let mut e = xml::ElementBuilder::new();

    let mut string = String::new();
    if let Err(err) = rdr.read_to_string(&mut string) {
        println!("Reading failed: {}", err);
        std::process::exit(1);
    };

    p.feed_str(&string);
    for event in p.filter_map(|x| e.handle_event(x)) {
        // println!("{:?}", event);
        match event {
            Ok(e) => println!("{}", e),
            Err(e) => println!("{}", e),
        }
    }
}