Enum git_config::parser::Event

pub enum Event<'a> {
    Comment(ParsedComment<'a>),
    SectionHeader(ParsedSectionHeader<'a>),
    Key(Key<'a>),
    Value(Cow<'a, [u8]>),
    Newline(Cow<'a, str>),
    ValueNotDone(Cow<'a, [u8]>),
    ValueDone(Cow<'a, [u8]>),
    Whitespace(Cow<'a, str>),
    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 smart pointer is used here for ease of inserting events in a middle of an Event iterator. This is used, for example, in the GitConfig struct when adding values.

Variants

Comment(ParsedComment<'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.

SectionHeader(ParsedSectionHeader<'a>)

A section header containing the section name and a subsection, if it exists.

Key(Key<'a>)

A name to a value in a section.

Value(Cow<'a, [u8]>)

A completed value. This may be any 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 it may contain double quotes that should be replaced.

Newline(Cow<'a, str>)

Represents any token used to signify a new line 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.

ValueNotDone(Cow<'a, [u8]>)

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

ValueDone(Cow<'a, [u8]>)

The last line of a value which was continued onto another line.

Whitespace(Cow<'a, str>)

A continuous section of insignificant whitespace. Values with internal spaces will not be separated by this event.

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_vec(&self) -> Vec<u8>

Generates a byte representation of the value. This should be used when non-UTF-8 sequences are present or a UTF-8 representation can’t be guaranteed.

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

Coerces into an owned instance. This differs from the standard clone implementation as calling clone will not copy the borrowed variant, while this method will. In other words:

Borrow type	.clone()	to_owned()
Borrowed	Borrowed	Owned
Owned	Owned	Owned

This can be most effectively seen by the differing lifetimes between the two. This method guarantees a 'static lifetime, while clone does not.

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

Note that this is a best-effort attempt at printing an Event. If there are non UTF-8 values in your config, this will NOT render as read.

impl From<&'_ Event<'_>> for Vec<u8>

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

Converts to this type from the input type.

impl From<Event<'_>> for Vec<u8>

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

Converts to this type from the input type.

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

fn from(header: ParsedSectionHeader<'_>) -> 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, 

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

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

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

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Event<'a>) -> bool

This method tests for !=.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a> Eq for Event<'a>

impl<'a> StructuralEq for Event<'a>

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