Enum Event 

pub enum Event<'t, 'a, 'v> {
    Command(&'t Command<'t>),
    Flag {
        flag: &'t Flag<'t>,
        value: Option<&'v [u8]>,
        negated: bool,
    },
    Arg {
        arg: &'t Arg<'t>,
        value: &'v [u8],
        delimit: bool,
    },
    ClauseSeparator {
        clause: Clause<'t>,
    },
    External {
        values: &'a [&'v OsStr],
    },
}

Something the parser bound.

Variants

Command(&'t Command<'t>)

A subcommand was selected; parsing continues inside it.

Flag

A flag was given. value is Some for a flag that takes one, and negated is true when the flag was set through its negate form.

Fields

flag: &'t Flag<'t>

value: Option<&'v [u8]>

negated: bool

Arg

A word was bound to a positional argument. A variadic argument produces one event per value.

Fields

arg: &'t Arg<'t>

value: &'v [u8]

delimit: bool

Whether this value should be split by the argument’s declared delimiter.

ClauseSeparator

Ended one clause instance and began the next.

Fields

clause: Clause<'t>

External

An unmatched word was forwarded as an external command: the name, then every remaining token, including flags.

Fields

values: &'a [&'v OsStr]

Trait Implementations

impl<'t, 'a, 'v> Clone for Event<'t, 'a, 'v>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'t, 'a, 'v> Copy for Event<'t, 'a, 'v>

impl<'t, 'a, 'v> Debug for Event<'t, 'a, 'v>

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

Formats the value using the given formatter.

impl<'t, 'a, 'v> Eq for Event<'t, 'a, 'v>

impl<'t, 'a, 'v> PartialEq for Event<'t, 'a, 'v>

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

Equality operator ==.

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

Inequality operator !=.

impl<'t, 'a, 'v> StructuralPartialEq for Event<'t, 'a, 'v>