Enum xml::reader::XmlEvent

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

StartDocument	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 version XML version. If XML declaration is not present, defaults to Version10. encoding 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. standalone 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.
EndDocument	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.
ProcessingInstruction	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 name Processing instruction target. data Processing instruction content.
StartElement	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 name Qualified name of the element. attributes A list of attributes associated with the element. Currently attributes are not checked for duplicates (TODO) namespace Contents of the namespace mapping at this point of the document.
EndElement	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 name Qualified name of the element.
CData	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.
Comment	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.
Characters	Denotes character data outside of tags. Contents of this event will always be unescaped, so no entities like < or & or { 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.
Whitespace	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

fn as_writer_event<'a>(&'a self) -> Option<XmlEvent<'a>>

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 Debug for XmlEvent

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

Derived Implementations

impl Clone for XmlEvent

fn clone(&self) -> XmlEvent

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl PartialEq for XmlEvent

fn eq(&self, __arg_0: &XmlEvent) -> bool

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

fn ne(&self, __arg_0: &XmlEvent) -> bool

This method tests for !=.