Macro aopt::prelude::getopt

macro_rules! getopt {
    ($args:expr, $($parser_left:path),+) => { ... };
    ($args:expr, $(&mut $parser_left:path),+) => { ... };
    ($args:expr, $($parser_name:literal => $parser_left:path),+) => { ... };
    ($args:expr, $($parser_name:literal => &mut $parser_left:path),+) => { ... };
}

Parse the string sequence with given Parser.

Returns

For style getopt!(..., &mut parser1, &mut parser2), will return an Ok(GetoptRes(T is the type of matched Parser)) if any Parser parsing successed. For style getopt!(..., "first" => &mut parser1, "second" => &mut parser2), will return an Ok(GetoptRes(T is the literal type)) if any Parser parsing successed.

Will return Err(Error::default()) if all Parser parsing failed, otherwise return Err(_).

Example

let mut parser = AFwdParser::default();
let mut pre_parser = APreParser::default();

{
    parser.add_opt("-a=b!")?;
    parser.add_opt("--bopt=i")?;
    parser.add_opt("c=p@-0")?.on(
        |_: &mut ASet, _: &mut ASer, args: ctx::Args, mut val: ctx::Value<String>| {
            assert_eq!(args[0], RawVal::from("foo"));
            Ok(Some(val.take()))
        },
    )?;

    assert!(getopt!(Args::from(["-a", "--bopt=42", "foo"]), &mut parser).is_ok());
    assert_eq!(parser.find_val::<bool>("-a")?, &true);
    assert_eq!(parser.find_val::<i64>("--bopt")?, &42i64);
}
{
    pre_parser.add_opt("-d".infer::<String>())?.set_values(vec![]);
    pre_parser.add_opt("--eopt=s")?;

    let ret = getopt!(
        Args::from(["-dbar", "-d", "foo", "--eopt=pre", "foo"]),
        &mut pre_parser
    )?;
    let args = ret.ret.clone_args();
    let parser = ret.parser;

    assert_eq!(
        parser.find_vals::<String>("-d")?,
        &vec!["bar".to_owned(), "foo".to_owned()],
    );
    assert_eq!(parser.find_val::<String>("--eopt")?, &String::from("pre"));
    assert_eq!(args, vec![RawVal::from("foo")] );
}

parser.reset()?;
pre_parser.reset()?;

{
    let ret = getopt!(
        Args::from(["-a", "--bopt=42", "foo"]),
        "parser" => &mut parser,
        "pre" => &mut pre_parser
    )?;

    assert_eq!(ret.parser, "parser");
    assert_eq!(parser.find_val::<bool>("-a")?, &true);
    assert_eq!(parser.find_val::<i64>("--bopt")?, &42i64);
}
{
    let res = getopt!(
        Args::from(["-dbar", "-d", "foo", "--eopt=pre", "foo"]),
        "parser" => &mut parser,
        "pre" => &mut pre_parser
    )?;
    let args = res.ret.clone_args();

    assert_eq!(res.parser, "pre");
    assert_eq!(
        pre_parser.find_vals::<String>("-d")?,
        &vec!["bar".to_owned(), "foo".to_owned()],
    );
    assert_eq!(pre_parser.find_val::<String>("--eopt")?, &String::from("pre"));
    assert_eq!(args, vec![RawVal::from("foo")]);
}