Enum EventKind 

pub enum EventKind<'src> {
    DocumentStart,
    DocumentEnd,
    ObjectStart,
    ObjectEnd,
    SequenceStart,
    SequenceEnd,
    EntryStart,
    Key {
        tag: Option<&'src str>,
        payload: Option<Cow<'src, str>>,
        kind: ScalarKind,
    },
    EntryEnd,
    Scalar {
        value: Cow<'src, str>,
        kind: ScalarKind,
    },
    Unit,
    TagStart {
        name: &'src str,
    },
    TagEnd,
    Comment {
        text: &'src str,
    },
    DocComment {
        lines: Vec<&'src str>,
    },
    Error {
        kind: ParseErrorKind,
    },
}

The kind of event emitted by the parser.

Variants

DocumentStart

Start of document.

DocumentEnd

End of document.

ObjectStart

Start of an object { ... }.

ObjectEnd

End of an object.

SequenceStart

Start of a sequence ( ... ).

SequenceEnd

End of a sequence.

EntryStart

Start of an entry (key-value pair).

Key

A key in an entry.

Keys can be scalars or unit, optionally tagged. Objects, sequences, and heredocs are not allowed as keys.

Fields

tag: Option<&'src str>

Tag name if this key is tagged (without @).

payload: Option<Cow<'src, str>>

Scalar payload after escape processing. None means unit.

kind: ScalarKind

Kind of scalar used for the key. Only meaningful if payload is Some.

EntryEnd

End of an entry.

Scalar

A scalar value.

Fields

value: Cow<'src, str>

Value after escape processing.

kind: ScalarKind

Kind of scalar.

Unit

Unit value @.

TagStart

Start of a tag @name.

Fields

name: &'src str

Tag name (without @).

TagEnd

End of a tag.

Comment

Line comment // ....

Fields

text: &'src str

Comment text (including //).

DocComment

Doc comment /// ....

Fields

lines: Vec<&'src str>

Doc comment lines (without /// prefix).

Error

Parse error.

Fields

kind: ParseErrorKind

Kind of error.

Trait Implementations

impl<'src> Clone for EventKind<'src>

fn clone(&self) -> EventKind<'src>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'src> Debug for EventKind<'src>

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

Formats the value using the given formatter.

impl<'src> PartialEq for EventKind<'src>

fn eq(&self, other: &EventKind<'src>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'src> Eq for EventKind<'src>

impl<'src> StructuralPartialEq for EventKind<'src>