Struct palex::StringInput

pub struct StringInput<I: Iterator<Item = String> = Args> { /* fields omitted */ }

The default input type for argument parsing. This is generic over its iterator type and can be used with std::env::args. See StringInput::new() for more information.

Getting the current token and token kind is very cheap. Bumping the token is a bit more expensive, since it involves more complicated logic and might re-allocate.

Implementations

impl<I: Iterator<Item = String>> StringInput<I>

pub fn new(iter: I) -> Self

Creates a new instance of this input.

Example:

let mut _input = StringInput::new(std::env::args());

You probably want to discard the first argument in this case, which is just the path to the executable.

Trait Implementations

impl<I: Iterator<Item = String>> Input for StringInput<I>

fn current(&self) -> Option<(&str, TokenKind)>

Returns the current token as string slice and the TokenKind of the current token, or None if the input is empty.

fn current_str_with_leading_dashes(&self) -> Option<&str>

Returns the current token (including the leading dashes) as string slice, or None if the input is empty.

fn bump(&mut self, len: usize) -> &str

Bumps the current token by len bytes.

fn bump_with_leading_dashes(&mut self, len: usize) -> &str

Bumps the current token (including leading dashes) by len bytes.

fn bump_argument(&mut self) -> Option<&str>

Bumps the current argument (including leading dashes) completely.

fn set_ignore_dashes(&mut self, ignore: bool)

Sets the parsing mode. When true, all arguments are considered positional, i.e. leading dashes are ignored.

fn ignore_dashes(&self) -> bool

Returns the parsing mode. When true, all arguments are considered positional, i.e. leading dashes are ignored.

fn is_empty(&self) -> bool

Returns true if the input is empty. This means that all arguments have been fully parsed.

fn is_not_empty(&self) -> bool

Returns true if the input is not empty. This means that all arguments have been fully parsed.

fn can_parse_value_no_whitespace(&self) -> bool

Returns true if a value within the same argument is expected. Or in other words, if we just consumed a single-dash flag or an equals sign and there are remaining bytes in the same argument.

fn can_parse_dash_argument(&self) -> bool

Returns true if the current token can be parsed as a flag or named argument (e.g. -h, --help=config).

fn eat_no_dash<'a>(&mut self, token: &'a str) -> Option<&str>

Eat the current token if the argument doesn't start with dashes and matches token exactly.

fn eat_one_dash<'a>(&mut self, token: &'a str) -> Option<&str>

Eat the current token if the argument starts with a single dash, and the current token starts with token.

fn eat_two_dashes<'a>(&mut self, token: &'a str) -> Option<&str>

Eat the current token if the argument starts with (at least) two dashes, and the current token either matches token exactly, or starts with token followed by an equals sign.

fn eat_value<'a>(&mut self, token: &'a str) -> Option<&str>

Eat the current token if it matches token exactly.

fn eat_value_allows_leading_dashes<'a>(
    &mut self,
    token: &'a str
) -> Option<&str>

Eat the current token (including any leading dashes) if it matches token exactly.

fn no_dash(&mut self) -> Option<InputPart<'_, Self>> where
    Self: Sized, 

If the argument doesn't start with dashes, returns a helper struct for obtaining, validating and eating the next token.

fn one_dash(&mut self) -> Option<InputPart<'_, Self>> where
    Self: Sized, 

If the argument starts with a single dash, returns a helper struct for obtaining, validating and eating the next token.

fn two_dashes(&mut self) -> Option<InputPart<'_, Self>> where
    Self: Sized, 

If the argument starts with two (or more) dashes, returns a helper struct for obtaining, validating and eating the next token.

fn value(&mut self) -> Option<InputPart<'_, Self>> where
    Self: Sized, 

Returns a helper struct for obtaining, validating and eating the next token. Works only if the current TokenKind is either NoDash, AfterOneDash or AfterEquals.

fn value_allows_leading_dashes(&mut self) -> Option<InputPartLD<'_, Self>> where
    Self: Sized, 

Returns a helper struct for obtaining, validating and eating the next token. The value is allowed to start with a dash.