Enum Opt 

pub enum Opt {
    NonOption(String),
    Dash,
    Short(String),
    ShortPair(String, String),
    ShortIncomplete(String),
    Long(String),
    LongPair(String, String),
    Terminator,
}

All possible options/non-options which can be parsed from arguments

Variants

NonOption(String)

file (plain non-option argument)

Dash

- (just a dash; usually for stdin)

Short(String)

-x alphanumeric character “x”

ShortPair(String, String)

-xBAR or -x BAR

ShortIncomplete(String)

-x <EOF> (expected pair; found EOF)

Long(String)

--example

LongPair(String, String)

--example=[value]

Terminator

-- (forces all later arguments to be non-options)

Implementations

impl Opt

pub fn simplify(&self) -> SimpleOpt<'_>

Converts an Opt into a SimpleOpt.

See SimpleOpt variants for a description of the variant conversion.

Examples

Consider the following command:

$ program arg1 -abcx12 -y 3 --long --key=value - arg2 -- -kh --ignore

The following code simulates parsing of the command above:

use argsyn::ArgsExt;

let cmd = "program arg1 -abcx12 -y 3 --long --key=value - arg2 -- -kh --ignore";

let args = cmd
  .split_ascii_whitespace()
  .into_iter()
  .map(|s| s.to_string());

for opt in args.opts("xy").unwrap() {
  println!("{:?}", opt.simplify());
}

Running the above code produces the following output:

Basic("program")
Basic("arg1")
Flag("a")
Flag("b")
Flag("c")
Pair("x", "12")
Pair("y", "3")
Flag("long")
Pair("key", "value")
Stdin
Basic("arg2")
Done
Basic("-kh")
Basic("--ignore")

See ArgsExt::opts for the same example but without simplification.

Trait Implementations

impl Clone for Opt

fn clone(&self) -> Opt

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Opt

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

Formats the value using the given formatter.

impl Display for Opt

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

Formats the value using the given formatter.

impl<'a> From<SimpleOpt<'a>> for Opt

fn from(value: SimpleOpt<'a>) -> Self

Converts to this type from the input type.

impl Hash for Opt

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 Ord for Opt

fn cmp(&self, other: &Opt) -> 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 PartialEq for Opt

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

fn partial_cmp(&self, other: &Opt) -> 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 Eq for Opt

impl StructuralPartialEq for Opt