Enum XmlEvent

pub enum XmlEvent<'a> {
    StartDocument {
        version: XmlVersion,
        encoding: Option<&'a str>,
        standalone: Option<bool>,
    },
    ProcessingInstruction {
        name: &'a str,
        data: Option<&'a str>,
    },
    StartElement {
        name: Name<'a>,
        attributes: Cow<'a, [Attribute<'a>]>,
        namespace: Cow<'a, Namespace>,
    },
    EndElement {
        name: Option<Name<'a>>,
    },
    CData(&'a str),
    Comment(&'a str),
    Characters(&'a str),
}

A part of an XML output stream.

Objects of this enum are consumed by EventWriter. They correspond to different parts of an XML document.

Variants

StartDocument

Corresponds to XML document declaration.

This event should always be written before any other event. If it is not written at all, a default XML declaration will be outputted if the corresponding option is set in the configuration. Otherwise an error will be returned.

Fields

version: XmlVersion

XML version.

Defaults to XmlVersion::Version10.

encoding: Option<&'a str>

XML document encoding.

Defaults to Some("UTF-8").

standalone: Option<bool>

XML standalone declaration.

Defaults to None.

ProcessingInstruction

Denotes an XML processing instruction.

Fields

name: &'a str

Processing instruction target.

data: Option<&'a str>

Processing instruction content.

StartElement

Denotes a beginning of an XML element.

Fields

name: Name<'a>

Qualified name of the element.

attributes: Cow<'a, [Attribute<'a>]>

A list of attributes associated with the element.

Currently attributes are not checked for duplicates (TODO). Attribute values will be escaped, and all characters invalid for attribute values like " or < will be changed into character entities.

namespace: Cow<'a, Namespace>

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

This mapping will be inspected for “new” entries, and if at this point of the document a particular pair of prefix and namespace URI is already defined, no namespace attributes will be emitted.

EndElement

Denotes an end of an XML element.

Fields

name: Option<Name<'a>>

Optional qualified name of the element.

If None, then it is assumed that the element name should be the last valid one. If Some and element names tracking is enabled, then the writer will check it for correctness.

CData(&'a str)

Denotes CDATA content.

This event contains unparsed data, and no escaping will be performed when writing it to the output stream.

Comment(&'a str)

Denotes a comment.

The string will be checked for invalid sequences and error will be returned by the write operation

Characters(&'a str)

Denotes character data outside of tags.

Contents of this event will be escaped if perform_escaping option is enabled, that is, every character invalid for PCDATA will appear as a character entity.

Implementations

impl<'a> XmlEvent<'a>

pub const fn processing_instruction( name: &'a str, data: Option<&'a str>, ) -> Self

Returns an writer event for a processing instruction.

pub fn start_element<S>(name: S) -> StartElementBuilder<'a>

where S: Into<Name<'a>>,

Returns a builder for a starting element.

This builder can then be used to tweak attributes and namespace starting at this element.

pub const fn end_element() -> EndElementBuilder<'a>

Returns a builder for an closing element.

This method, unline start_element(), does not accept a name because by default the writer is able to determine it automatically. However, when this functionality is disabled, it is possible to specify the name with name() method on the builder.

pub const fn cdata(data: &'a str) -> Self

Returns a CDATA event.

Naturally, the provided string won’t be escaped, except for closing CDATA token ]]> (depending on the configuration).

pub const fn characters(data: &'a str) -> Self

Returns a regular characters (PCDATA) event.

All offending symbols, in particular, & and <, will be escaped by the writer.

pub const fn comment(data: &'a str) -> Self

Returns a comment event.

Trait Implementations

impl<'a> Clone for XmlEvent<'a>

fn clone(&self) -> XmlEvent<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for XmlEvent<'a>

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

Formats the value using the given formatter.

impl<'a> From<&'a str> for XmlEvent<'a>

fn from(s: &'a str) -> Self

Converts to this type from the input type.

impl<'a> From<EndElementBuilder<'a>> for XmlEvent<'a>

fn from(b: EndElementBuilder<'a>) -> Self

Converts to this type from the input type.

impl<'a> From<StartElementBuilder<'a>> for XmlEvent<'a>

fn from(b: StartElementBuilder<'a>) -> Self

Converts to this type from the input type.