Enum gix_config::parse::Event

pub enum Event<'a> {
    Comment(Comment<'a>),
    SectionHeader(Header<'a>),
    SectionValueName(ValueName<'a>),
    Value(Cow<'a, BStr>),
    Newline(Cow<'a, BStr>),
    ValueNotDone(Cow<'a, BStr>),
    ValueDone(Cow<'a, BStr>),
    Whitespace(Cow<'a, BStr>),
    KeyValueSeparator,
}

Syntactic events that occurs in the config. Despite all these variants holding a Cow instead over a simple reference, the parser will only emit borrowed Cow variants.

The Cow is used here for ease of inserting new, typically owned events as used in the File struct when adding values, allowing a mix of owned and borrowed values.

Variants

Comment(Comment<'a>)

A comment with a comment tag and the comment itself. Note that the comment itself may contain additional whitespace and comment markers at the beginning, like # comment or ; comment.

SectionHeader(Header<'a>)

A section header containing the section name and a subsection, if it exists. For instance, remote "origin" is parsed to remote as section name and origin as subsection name.

SectionValueName(ValueName<'a>)

A name to a value in a section, like url in remote.origin.url.

Value(Cow<'a, BStr>)

A completed value. This may be any single-line string, including the empty string if an implicit boolean value is used. Note that these values may contain spaces and any special character. This value is also unprocessed, so it may contain double quotes that should be normalized before interpretation.

Newline(Cow<'a, BStr>)

Represents any token used to signify a newline character. On Unix platforms, this is typically just \n, but can be any valid newline sequence. Multiple newlines (such as \n\n) will be merged as a single newline event containing a string of multiple newline characters.

ValueNotDone(Cow<'a, BStr>)

Any value that isn’t completed. This occurs when the value is continued onto the next line by ending it with a backslash. A Newline event is guaranteed after, followed by either a ValueDone, a Whitespace, or another ValueNotDone.

ValueDone(Cow<'a, BStr>)

The last line of a value which was continued onto another line. With this it’s possible to obtain the complete value by concatenating the prior ValueNotDone events.

Whitespace(Cow<'a, BStr>)

A continuous section of insignificant whitespace.

Note that values with internal whitespace will not be separated by this event, hence interior whitespace there is always part of the value.

KeyValueSeparator

This event is emitted when the parser counters a valid = character separating the key and value. This event is necessary as it eliminates the ambiguity for whitespace events between a key and value event.

Implementations

impl Event<'_>

pub fn to_bstring(&self) -> BString

Serialize this type into a BString for convenience.

Note that to_string() can also be used, but might not be lossless.

pub fn to_bstr_lossy(&self) -> &BStr

Turn ourselves into the text we represent, lossy.

Note that this will be partial in case of ValueNotDone which doesn’t include the backslash, and SectionHeader will only provide their name, lacking the sub-section name.

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

Stream ourselves to the given out, in order to reproduce this event mostly losslessly as it was parsed.

pub fn to_owned(&self) -> Event<'static>

Turn this instance into a fully owned one with 'static lifetime.

Trait Implementations

impl<'a> Clone for Event<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Event<'a>

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

Formats the value using the given formatter.

impl Display for Event<'_>

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

Formats the value using the given formatter.

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

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

Converts to this type from the input type.

impl From<Event<'_>> for BString

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

Converts to this type from the input type.

impl<'a> From<Header<'a>> for Event<'a>

fn from(header: Header<'_>) -> Event<'_>

Converts to this type from the input type.

impl<'a> Hash for Event<'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 Event<'a>

fn cmp(&self, other: &Event<'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 + PartialOrd,

Restrict a value to a certain interval.

impl<'a> PartialEq for Event<'a>

fn eq(&self, other: &Event<'a>) -> 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<'a> PartialOrd for Event<'a>

fn partial_cmp(&self, other: &Event<'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> Eq for Event<'a>

impl<'a> StructuralPartialEq for Event<'a>