Enum xml::reader::XmlEvent [] [src]

pub enum XmlEvent {
    StartDocument {
        version: XmlVersion,
        encoding: String,
        standalone: Option<bool>,
    },
    EndDocument,
    ProcessingInstruction {
        name: String,
        data: Option<String>,
    },
    StartElement {
        name: OwnedName,
        attributes: Vec<OwnedAttribute>,
        namespace: Namespace,
    },
    EndElement {
        name: OwnedName,
    },
    CData(String),
    Comment(String),
    Characters(String),
    Whitespace(String),
}

An element of an XML input stream.

Items of this enum are emitted by reader::EventReader. They correspond to different elements of an XML document.

Variants

Corresponds to XML document declaration.

This event is always emitted before any other event. It is emitted even if the actual declaration is not present in the document.

Fields of StartDocument

XML version.

If XML declaration is not present, defaults to Version10.

XML document encoding.

If XML declaration is not present or does not contain encoding attribute, defaults to "UTF-8". This field is currently used for no other purpose than informational.

XML standalone declaration.

If XML document is not present or does not contain standalone attribute, defaults to None. This field is currently used for no other purpose than informational.

Denotes to the end of the document stream.

This event is always emitted after any other event (except Error). After it is emitted for the first time, it will always be emitted on next event pull attempts.

Denotes an XML processing instruction.

This event contains a processing instruction target (name) and opaque data. It is up to the application to process them.

Fields of ProcessingInstruction

Processing instruction target.

Processing instruction content.

Denotes a beginning of an XML element.

This event is emitted after parsing opening tags or after parsing bodiless tags. In the latter case EndElement event immediately follows.

Fields of StartElement

Qualified name of the element.

A list of attributes associated with the element.

Currently attributes are not checked for duplicates (TODO)

Contents of the namespace mapping at this point of the document.

Denotes an end of an XML element.

This event is emitted after parsing closing tags or after parsing bodiless tags. In the latter case it is emitted immediately after corresponding StartElement event.

Fields of EndElement

Qualified name of the element.

Denotes CDATA content.

This event contains unparsed data. No unescaping will be performed.

It is possible to configure a parser to emit Characters event instead of CData. See pull::ParserConfiguration structure for more information.

Denotes a comment.

It is possible to configure a parser to ignore comments, so this event will never be emitted. See pull::ParserConfiguration structure for more information.

Denotes character data outside of tags.

Contents of this event will always be unescaped, so no entities like &lt; or &amp; or &#123; will appear in it.

It is possible to configure a parser to trim leading and trailing whitespace for this event. See pull::ParserConfiguration structure for more information.

Denotes a chunk of whitespace outside of tags.

It is possible to configure a parser to emit Characters event instead of Whitespace. See pull::ParserConfiguration structure for more information. When combined with whitespace trimming, it will eliminate standalone whitespace from the event stream completely.

Methods

impl XmlEvent
[src]

Obtains a writer event from this reader event.

This method is useful for streaming processing of XML documents where the output is also an XML document. With this method it is possible to process some events while passing other events through to the writer unchanged:

use std::str;

use xml::{EventReader, EventWriter};
use xml::reader::XmlEvent as ReaderEvent;
use xml::writer::XmlEvent as WriterEvent;

let mut input: &[u8] = b"<hello>world</hello>";
let mut output: Vec<u8> = Vec::new();

{
    let mut reader = EventReader::new(&mut input);
    let mut writer = EventWriter::new(&mut output);

    for e in reader {
        match e.unwrap() {
            ReaderEvent::Characters(s) =>
                writer.write(WriterEvent::characters(&s.to_uppercase())).unwrap(),
            e => if let Some(e) = e.as_writer_event() {
                writer.write(e).unwrap()
            }
        }
    }
}

assert_eq!(
    str::from_utf8(&output).unwrap(),
    r#"<?xml version="1.0" encoding="UTF-8"?><hello>WORLD</hello>"#
);

Note that this API may change or get additions in future to improve its ergonomics.

Trait Implementations

impl PartialEq for XmlEvent
[src]

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

impl Clone for XmlEvent
[src]

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

impl Debug for XmlEvent
[src]

Formats the value using the given formatter.