Struct Parser

Source

pub struct Parser<S, P: Policy<Set = S>> {
    pub policy: P,
    pub optset: S,
}

Expand description

Parser manage the components are using in parse of Policy.

§Example

let mut parser1 = Parser::new_policy(AFwdPolicy::default());

parser1.add_opt("Where=c")?;
parser1.add_opt("question=m")?.on(question)?;

let mut parser2 = Parser::new_policy(AFwdPolicy::default());

parser2.add_opt("Who=c")?;
parser2.add_opt("question=m")?.on(question)?;

fn question(_: &mut AHCSet, ctx: &mut Ctx) -> Result<Option<()>, Error> {
    let args = ctx.args();
    // Output: The question is: Where are you from ?
    println!(
        "The question is: {}",
        args.iter().skip(1)
            .map(|v| v.to_str().unwrap().to_owned())
            .collect::<Vec<String>>()
            .join(" ")
    );
    Ok(Some(()))
}

let ret = getopt!(
    Args::from(["app", "Where", "are", "you", "from", "?"]),
    &mut parser1,
    &mut parser2
)?;
let parser = ret.parser;

assert_eq!(
    parser[0].name(),
    "Where",
    "Parser with `Where` cmd matched"
);

Using it with macro getopt, which can process multiple Parser with same type Policy.

Fields§

§policy: P§optset: S

Implementations§

Source §

impl<'a, S, P> Parser<HCOptSet<'a, S>, P>
where S: Default, P: Policy<Set = HCOptSet<'a, S>, Inv<'a> = Invoker<'a, HCOptSet<'a, S>>>,

Source

pub fn new_policy(policy: P) -> Self

Source

pub fn new_with( policy: P, optset: S, invoker: Invoker<'a, HCOptSet<'a, S>>, ) -> Self

Source §

impl<'a, S, P> Parser<HCOptSet<'a, S>, P>
where S: Set, P: Policy<Set = HCOptSet<'a, S>, Inv<'a> = Invoker<'a, HCOptSet<'a, S>>>,

Source

pub fn reset(&mut self) -> Result<&mut Self, Error>

Reset the option set.

Source

pub fn init(&mut self) -> Result<(), Error>

Call the init of Opt initialize the option value.

Source

pub fn parse(&mut self, args: Args) -> Result<::Ret, Error>

Examples found in repository ?

examples/02_option_value.rs (lines 12-14)

3pub fn main() -> Result<(), aopt::Error> {
4    let mut parser = AFwdParser::default();
5
6    // add option need argument with type `i`, i.e. i64
7    parser.add_opt("-f=i")?;
8    parser.add_opt("--flag=s")?;
9    parser.add_opt("-flag".infer::<f32>())?;
10
11    parser
12        .parse(Args::from(
13            ["app", "-f42", "--flag", "foo", "-flag=2.1"].into_iter(),
14        ))?
15        .ok()?;
16
17    assert_eq!(parser.find_val::<i64>("-f")?, &42);
18    assert_eq!(parser.find_val::<String>("--flag")?, "foo");
19    assert_eq!(parser.find_val::<f32>("-flag")?, &2.1);
20
21    Ok(())
22}

More examples

Hide additional examples

examples/06_callback.rs (line 16)

3pub fn main() -> Result<(), aopt::Error> {
4    let mut parser = AFwdParser::default();
5
6    parser.add_opt("-flag".infer::<i32>())?.on(|_, _| {
7        println!("ignore the value set from command line");
8        Ok(Some(42))
9    })?;
10    parser
11        .add_opt("--/flag".infer::<bool>())?
12        .set_value(true)
13        .on(|_, ctx| Ok(Some(!ctx.value::<bool>()?)))?;
14
15    parser
16        .parse(Args::from(["app", "-flag=foo", "--/flag"].into_iter()))?
17        .ok()?;
18
19    assert_eq!(parser.find_val::<i32>("-flag")?, &42);
20    assert_eq!(parser.find_val::<bool>("--/flag")?, &false);
21
22    Ok(())
23}

examples/07_callback.rs (line 20)

11pub fn main() -> Result<(), aopt::Error> {
12    let mut parser = AFwdParser::default();
13
14    parser.add_opt("-flag;--flag=b")?.on(changed("--/flag"))?;
15    parser
16        .add_opt("-/flag;--/flag=b")?
17        .set_value_t(true)
18        .on(changed("--flag"))?;
19    parser
20        .parse(Args::from(["app", "-flag"].into_iter()))?
21        .ok()?;
22
23    assert_eq!(parser.find_val::<bool>("-flag")?, &true);
24    assert_eq!(parser.find_val::<bool>("--/flag")?, &false);
25
26    parser
27        .parse(Args::from(["app", "--/flag"].into_iter()))?
28        .ok()?;
29
30    assert_eq!(parser.find_val::<bool>("-flag")?, &false);
31    assert_eq!(parser.find_val::<bool>("--/flag")?, &true);
32
33    Ok(())
34}

examples/05_overload.rs (lines 13-15)

3pub fn main() -> Result<(), aopt::Error> {
4    let mut parser = AFwdParser::default();
5
6    parser.add_opt("-flag".infer::<i32>())?;
7    parser.add_opt("-flag".infer::<String>())?;
8    parser.add_opt("-flag".infer::<bool>())?;
9
10    // enable combination style
11    parser.set_overload(true);
12    parser
13        .parse(Args::from(
14            ["app", "-flag=foo", "-flag=42", "-flag"].into_iter(),
15        ))?
16        .ok()?;
17
18    assert_eq!(parser.find("-flag".infer::<i32>())?.val::<i32>()?, &42);
19    assert_eq!(
20        parser.find("-flag".infer::<String>())?.val::<String>()?,
21        "foo"
22    );
23    assert_eq!(parser.find("-flag".infer::<bool>())?.val::<bool>()?, &true);
24
25    Ok(())
26}

examples/04_positional.rs (lines 18-20)

3pub fn main() -> Result<(), aopt::Error> {
4    let mut parser = AFwdParser::default();
5
6    parser.add_opt("--flag=b")?;
7    parser.add_opt("--foo=s")?;
8    // In default, positional has bool value
9    parser.add_opt("first=p@1")?;
10    // A special positional argument match the name, and force required
11    parser.add_opt("list=c")?;
12    // Add a positional argument has String value
13    parser.add_opt("second@2".infer::<Pos<String>>())?;
14
15    // enable combination style
16    parser.enable_combined();
17    parser
18        .parse(Args::from(
19            ["app", "list", "--foo", "value", "bar"].into_iter(),
20        ))?
21        .ok()?;
22
23    assert_eq!(parser.find_val::<bool>("list")?, &true);
24    assert_eq!(parser.find_val::<bool>("first")?, &true);
25    assert_eq!(parser.find_val::<String>("second")?, "bar");
26
27    Ok(())
28}

examples/01_prefix_option.rs (line 10)

3pub fn main() -> Result<(), aopt::Error> {
4    let mut parser = AFwdParser::default();
5
6    // add option with value type `b`, i.e. option with bool value or flag
7    parser.add_opt("-f=b")?;
8    parser.add_opt("--flag".infer::<bool>())?;
9
10    parser.parse(Args::from(["app", "-f"].into_iter()))?.ok()?;
11
12    // option with bool type has default value `false`
13    assert_eq!(parser.find_val::<bool>("-f")?, &true);
14    assert_eq!(parser.find_val::<bool>("--flag")?, &false);
15
16    parser.add_opt("-flag=b!")?;
17    parser.add_opt("--/flag=b")?;
18
19    parser
20        .parse(Args::from(["app", "-flag", "--/flag"].into_iter()))?
21        .ok()?;
22
23    // option with bool type has default value `false`
24    assert_eq!(parser.find_val::<bool>("-flag")?, &true);
25    assert_eq!(parser.find_val::<bool>("--/flag")?, &true);
26
27    Ok(())
28}

Additional examples can be found in:

examples/03_combination_style.rs

Source §

impl<S, P> Parser<S, P>
where P: Policy<Set = S> + PolicySettings,

Source

pub fn enable_combined(&mut self) -> &mut Self

Enable CombinedOption option set style. This can support option style like -abc which set -a, -b and -c both.

Examples found in repository ?

examples/04_positional.rs (line 16)

3pub fn main() -> Result<(), aopt::Error> {
4    let mut parser = AFwdParser::default();
5
6    parser.add_opt("--flag=b")?;
7    parser.add_opt("--foo=s")?;
8    // In default, positional has bool value
9    parser.add_opt("first=p@1")?;
10    // A special positional argument match the name, and force required
11    parser.add_opt("list=c")?;
12    // Add a positional argument has String value
13    parser.add_opt("second@2".infer::<Pos<String>>())?;
14
15    // enable combination style
16    parser.enable_combined();
17    parser
18        .parse(Args::from(
19            ["app", "list", "--foo", "value", "bar"].into_iter(),
20        ))?
21        .ok()?;
22
23    assert_eq!(parser.find_val::<bool>("list")?, &true);
24    assert_eq!(parser.find_val::<bool>("first")?, &true);
25    assert_eq!(parser.find_val::<String>("second")?, "bar");
26
27    Ok(())
28}

More examples

Hide additional examples

examples/03_combination_style.rs (line 15)

3pub fn main() -> Result<(), aopt::Error> {
4    let mut parser = AFwdParser::default();
5
6    // combination style only support bool type
7    parser.add_opt("-a=b")?;
8    parser.add_opt("-b=b")?;
9    parser.add_opt("-c".infer::<bool>())?;
10    parser.add_opt("d=b")?;
11    parser.add_opt("e=b")?;
12    parser.add_opt("f".infer::<bool>())?;
13
14    // enable combination style
15    parser.enable_combined();
16    parser
17        .parse(Args::from(["app", "-abc", "def"].into_iter()))?
18        .ok()?;
19
20    assert_eq!(parser.find_val::<bool>("-a")?, &true);
21    assert_eq!(parser.find_val::<bool>("-b")?, &true);
22    assert_eq!(parser.find_val::<bool>("-c")?, &true);
23    assert_eq!(parser.find_val::<bool>("d")?, &false);
24    assert_eq!(parser.find_val::<bool>("e")?, &false);
25    assert_eq!(parser.find_val::<bool>("f")?, &false);
26
27    // for support non-prefix option, need add prefix `""`,
28    // and disable the strict flag of policy
29    parser.validator_mut().add_prefix("");
30    parser.set_strict(false);
31    parser
32        .parse(Args::from(["app", "-abc", "def"].into_iter()))?
33        .ok()?;
34
35    assert_eq!(parser.find_val::<bool>("-a")?, &true);
36    assert_eq!(parser.find_val::<bool>("-b")?, &true);
37    assert_eq!(parser.find_val::<bool>("-c")?, &true);
38    assert_eq!(parser.find_val::<bool>("d")?, &true);
39    assert_eq!(parser.find_val::<bool>("e")?, &true);
40    assert_eq!(parser.find_val::<bool>("f")?, &true);
41
42    Ok(())
43}

Source

pub fn enable_embedded_plus(&mut self) -> &mut Self

Enable EmbeddedValuePlus option set style. This can support option style like --opt42 which set --opt value to 42. In default the EmbeddedValue style only support one letter option such as -i.

Source