Enum XmlEvent 

#[non_exhaustive]
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),
    RawCharacters(&'a str),
    Doctype(&'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 (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future 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.

RawCharacters(&'a str)

Emits raw characters which will never be escaped.

This event is only used for writing to an output stream, there is no equivalent reader event. Care must be taken when using this event, as it can easily result non-well-formed documents.

Doctype(&'a str)

Syntax of the DOCTYPE, everyhing including < and >

Implementations

impl<'a> XmlEvent<'a>

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

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) -> XmlEvent<'a>

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) -> XmlEvent<'a>

Returns a regular characters (PCDATA) event.

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

pub const fn raw_characters(data: &'a str) -> XmlEvent<'a>

Returns a raw characters event.

No escaping takes place. This event is only used for writing to an output stream, there is no equivalent reader event. Care must be taken when using this event, as it can easily result non-well-formed documents.

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

Returns a comment event.

Trait Implementations

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

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

Returns a duplicate 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<(), Error>

Formats the value using the given formatter.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<'a> TryFrom<&'a XmlEvent> for XmlEvent<'a>

type Error = Error

The type returned in the event of a conversion error.

fn try_from( event: &XmlEvent, ) -> Result<XmlEvent<'_>, <XmlEvent<'a> as TryFrom<&'a XmlEvent>>::Error>

Performs the conversion.