Enum EventRef 

pub enum EventRef<'a> {
    Comment {
        tag: u8,
        text: &'a BStr,
    },
    SectionHeader {
        name: &'a BStr,
        separator: Option<&'a BStr>,
        subsection_name: Option<&'a BStr>,
    },
    SectionValueName(&'a BStr),
    Value(&'a BStr),
    Newline(&'a BStr),
    ValueNotDone(&'a BStr),
    ValueDone(&'a BStr),
    Whitespace(&'a BStr),
    KeyValueSeparator,
}

A view of a syntactic event in a parsed representation.

Values in parsed events can be stored as spans into an owning backing buffer. This type exposes their resolved byte-string references.

Variants

Comment

A comment with a comment tag and the comment itself.

Fields

tag: u8

The comment marker used.

text: &'a BStr

The parsed comment text.

SectionHeader

A section header with its name and optional subsection details.

Fields

name: &'a BStr

The section name.

separator: Option<&'a BStr>

The separator between section and subsection, if any.

subsection_name: Option<&'a BStr>

The subsection name, if any.

SectionValueName(&'a BStr)

A name to a value in a section.

Value(&'a BStr)

A completed value.

Newline(&'a BStr)

One or more consecutive line endings.

Both \n and \r\n are accepted, including mixed runs. Multiple line endings, such as \n\n, are merged into a single event whose byte string contains the entire run.

ValueNotDone(&'a BStr)

An incomplete continued value.

ValueDone(&'a BStr)

The final part of a continued value.

Whitespace(&'a BStr)

Insignificant whitespace.

KeyValueSeparator

A = separator between key and value.

Implementations

impl EventRef<'_>

pub fn to_bstr_lossy(&self) -> &BStr

Turn ourselves into the text we represent, lossy.

Note that this mirrors Event::to_bstr_lossy_in().

pub fn write_to(&self, out: &mut dyn Write) -> Result<()>

Stream ourselves to the given out, reproducing this event mostly losslessly.

Quoted subsection names are the exception: EventRef::SectionHeader contains the decoded subsection name, so this method escapes it again and may normalize its original escape spelling. The resulting header has the same subsection name, but may not be byte-for-byte identical to the parsed input.

Trait Implementations

impl<'a> Clone for EventRef<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for EventRef<'a>

impl<'a> Debug for EventRef<'a>

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

Formats the value using the given formatter.

impl Display for EventRef<'_>

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

Formats the value using the given formatter.

impl<'a> Eq for EventRef<'a>

impl From<&EventRef<'_>> for BString

fn from(event: &EventRef<'_>) -> Self

Converts to this type from the input type.

impl<'a> Hash for EventRef<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> Ord for EventRef<'a>

fn cmp(&self, other: &EventRef<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> PartialEq for EventRef<'a>

fn eq(&self, other: &EventRef<'a>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<'a> PartialOrd for EventRef<'a>

fn partial_cmp(&self, other: &EventRef<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> StructuralPartialEq for EventRef<'a>