Struct aopt::parser::Parser

source · 
pub struct Parser<'a, P: Policy> { /* private fields */ }
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 ASet, _: &mut ASer, args: ctx::Args) -> Result<Option<()>, Error> {
    // Output: The question is: Where are you from ?
    println!(
        "The question is: {}",
        args.iter().skip(1)
            .map(|v| v.get_str().unwrap().to_owned())
            .collect::<Vec<String>>()
            .join(" ")
    );
    Ok(Some(()))
}

let ret = getopt!(
    Args::from_array(["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.

Implementations§

source§

impl<'a, P> Parser<'a, P>where P: Policy + APolicyExt<P>,

source

pub fn new_policy(policy: P) -> Self

source§

impl<'a, P: Policy> Parser<'a, P>

source

pub fn new( policy: P, optset: HCOptSet<<P as Policy>::Set, <P as Policy>::Inv<'a>, <P as Policy>::Ser> ) -> Self

source

pub fn new_with( policy: P, optset: P::Set, invoker: P::Inv<'a>, valser: P::Ser ) -> Self

source

pub fn policy(&self) -> &P

source

pub fn policy_mut(&mut self) -> &mut P

source

pub fn set_policy(&mut self, policy: P) -> &mut Self

source

pub fn optset(&self) -> &HCOptSet<P::Set, P::Inv<'a>, P::Ser>

source

pub fn optset_mut(&mut self) -> &mut HCOptSet<P::Set, P::Inv<'a>, P::Ser>

source

pub fn set_optset( &mut self, optset: HCOptSet<P::Set, P::Inv<'a>, P::Ser> ) -> &mut Self

source§

impl<'a, P> Parser<'a, P>where P::Set: Set, P: Policy,

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: ARef<Args>) -> Result<<P as Policy>::Ret, Error>

Examples found in repository?
examples/02_option_value.rs (lines 12-14)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

pub fn main() -> Result<(), aopt::Error> {
    let mut parser = AFwdParser::default();

    // add option need argument with type `i`, i.e. i64
    parser.add_opt("-f=i")?;
    parser.add_opt("--flag=s")?;
    parser.add_opt_i::<f32>("-flag")?;

    parser
        .parse(ARef::new(Args::from(
            ["app", "-f42", "--flag", "foo", "-flag=2.1"].into_iter(),
        )))?
        .ok()?;

    assert_eq!(parser.find_val::<i64>("-f")?, &42);
    assert_eq!(parser.find_val::<String>("--flag")?, "foo");
    assert_eq!(parser.find_val::<f32>("-flag")?, &2.1);

    Ok(())
}
More examples
Hide additional examples
examples/06_callback.rs (lines 18-20)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

pub fn main() -> Result<(), aopt::Error> {
    let mut parser = AFwdParser::default();

    parser
        .add_opt_i::<i32>("-flag")?
        .on(|_: &mut ASet, _: &mut ASer| {
            println!("ignore the value set from command line");
            Ok(Some(42))
        })?;
    parser
        .add_opt_i::<bool>("--/flag")?
        .set_value(true)
        .on(|_: &mut ASet, _: &mut ASer, val: ctx::Value<bool>| Ok(Some(!*val)))?;

    parser
        .parse(ARef::new(Args::from(
            ["app", "-flag=foo", "--/flag"].into_iter(),
        )))?
        .ok()?;

    assert_eq!(parser.find_val::<i32>("-flag")?, &42);
    assert_eq!(parser.find_val::<bool>("--/flag")?, &false);

    Ok(())
}
examples/05_overload.rs (lines 13-15)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

pub fn main() -> Result<(), aopt::Error> {
    let mut parser = AFwdParser::default();

    parser.add_opt_i::<i32>("-flag")?;
    parser.add_opt_i::<String>("-flag")?;
    parser.add_opt_i::<bool>("-flag")?;

    // enable combination style
    parser.set_overload(true);
    parser
        .parse(ARef::new(Args::from(
            ["app", "-flag=foo", "-flag=42", "-flag"].into_iter(),
        )))?
        .ok()?;

    assert_eq!(parser.find_i::<i32>("-flag")?.unwrap().val::<i32>()?, &42);
    assert_eq!(
        parser.find_i::<String>("-flag")?.unwrap().val::<String>()?,
        "foo"
    );
    assert_eq!(
        parser.find_i::<bool>("-flag")?.unwrap().val::<bool>()?,
        &true
    );

    Ok(())
}
examples/04_positional.rs (lines 18-20)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

pub fn main() -> Result<(), aopt::Error> {
    let mut parser = AFwdParser::default();

    parser.add_opt("--flag=b")?;
    parser.add_opt("--foo=s")?;
    // In default, positional has bool value
    parser.add_opt("first=p@1")?;
    // A special positional argument match the name, and force required
    parser.add_opt("list=c")?;
    // Add a positional argument has String value
    parser.add_opt_i::<Pos<String>>("second@2")?;

    // enable combination style
    parser.enable_combined();
    parser
        .parse(ARef::new(Args::from(
            ["app", "list", "--foo", "value", "bar"].into_iter(),
        )))?
        .ok()?;

    assert_eq!(parser.find_val::<bool>("list")?, &true);
    assert_eq!(parser.find_val::<bool>("first")?, &true);
    assert_eq!(parser.find_val::<String>("second")?, "bar");

    Ok(())
}
examples/01_prefix_option.rs (line 11)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

pub fn main() -> Result<(), aopt::Error> {
    let mut parser = AFwdParser::default();

    // add option with value type `b`, i.e. option with bool value or flag
    parser.add_opt("-f=b")?;
    parser.add_opt_i::<bool>("--flag")?;

    parser
        .parse(ARef::new(Args::from(["app", "-f"].into_iter())))?
        .ok()?;

    // option with bool type has default value `false`
    assert_eq!(parser.find_val::<bool>("-f")?, &true);
    assert_eq!(parser.find_val::<bool>("--flag")?, &false);

    parser.add_opt("-flag=b!")?;
    parser.add_opt("--/flag=b")?;

    parser
        .parse(ARef::new(Args::from(
            ["app", "-flag", "--/flag"].into_iter(),
        )))?
        .ok()?;

    // option with bool type has default value `false`
    assert_eq!(parser.find_val::<bool>("-flag")?, &true);
    assert_eq!(parser.find_val::<bool>("--/flag")?, &true);

    Ok(())
}
examples/03_combination_style.rs (line 17)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

pub fn main() -> Result<(), aopt::Error> {
    let mut parser = AFwdParser::default();

    // combination style only support bool type
    parser.add_opt("-a=b")?;
    parser.add_opt("-b=b")?;
    parser.add_opt_i::<bool>("-c")?;
    parser.add_opt("d=b")?;
    parser.add_opt("e=b")?;
    parser.add_opt_i::<bool>("f")?;

    // enable combination style
    parser.enable_combined();
    parser
        .parse(ARef::new(Args::from(["app", "-abc", "def"].into_iter())))?
        .ok()?;

    assert_eq!(parser.find_val::<bool>("-a")?, &true);
    assert_eq!(parser.find_val::<bool>("-b")?, &true);
    assert_eq!(parser.find_val::<bool>("-c")?, &true);
    assert_eq!(parser.find_val::<bool>("d")?, &false);
    assert_eq!(parser.find_val::<bool>("e")?, &false);
    assert_eq!(parser.find_val::<bool>("f")?, &false);

    // for support non-prefix option, need add prefix `""`,
    // and disable the strict flag of policy
    parser.validator_mut().add_prefix("");
    parser.set_strict(false);
    parser
        .parse(ARef::new(Args::from(["app", "-abc", "def"].into_iter())))?
        .ok()?;

    assert_eq!(parser.find_val::<bool>("-a")?, &true);
    assert_eq!(parser.find_val::<bool>("-b")?, &true);
    assert_eq!(parser.find_val::<bool>("-c")?, &true);
    assert_eq!(parser.find_val::<bool>("d")?, &true);
    assert_eq!(parser.find_val::<bool>("e")?, &true);
    assert_eq!(parser.find_val::<bool>("f")?, &true);

    Ok(())
}
source§

impl<'a, P> Parser<'a, P>where P: Policy + 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)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

pub fn main() -> Result<(), aopt::Error> {
    let mut parser = AFwdParser::default();

    parser.add_opt("--flag=b")?;
    parser.add_opt("--foo=s")?;
    // In default, positional has bool value
    parser.add_opt("first=p@1")?;
    // A special positional argument match the name, and force required
    parser.add_opt("list=c")?;
    // Add a positional argument has String value
    parser.add_opt_i::<Pos<String>>("second@2")?;

    // enable combination style
    parser.enable_combined();
    parser
        .parse(ARef::new(Args::from(
            ["app", "list", "--foo", "value", "bar"].into_iter(),
        )))?
        .ok()?;

    assert_eq!(parser.find_val::<bool>("list")?, &true);
    assert_eq!(parser.find_val::<bool>("first")?, &true);
    assert_eq!(parser.find_val::<String>("second")?, "bar");

    Ok(())
}
More examples
Hide additional examples
examples/03_combination_style.rs (line 15)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

pub fn main() -> Result<(), aopt::Error> {
    let mut parser = AFwdParser::default();

    // combination style only support bool type
    parser.add_opt("-a=b")?;
    parser.add_opt("-b=b")?;
    parser.add_opt_i::<bool>("-c")?;
    parser.add_opt("d=b")?;
    parser.add_opt("e=b")?;
    parser.add_opt_i::<bool>("f")?;

    // enable combination style
    parser.enable_combined();
    parser
        .parse(ARef::new(Args::from(["app", "-abc", "def"].into_iter())))?
        .ok()?;

    assert_eq!(parser.find_val::<bool>("-a")?, &true);
    assert_eq!(parser.find_val::<bool>("-b")?, &true);
    assert_eq!(parser.find_val::<bool>("-c")?, &true);
    assert_eq!(parser.find_val::<bool>("d")?, &false);
    assert_eq!(parser.find_val::<bool>("e")?, &false);
    assert_eq!(parser.find_val::<bool>("f")?, &false);

    // for support non-prefix option, need add prefix `""`,
    // and disable the strict flag of policy
    parser.validator_mut().add_prefix("");
    parser.set_strict(false);
    parser
        .parse(ARef::new(Args::from(["app", "-abc", "def"].into_iter())))?
        .ok()?;

    assert_eq!(parser.find_val::<bool>("-a")?, &true);
    assert_eq!(parser.find_val::<bool>("-b")?, &true);
    assert_eq!(parser.find_val::<bool>("-c")?, &true);
    assert_eq!(parser.find_val::<bool>("d")?, &true);
    assert_eq!(parser.find_val::<bool>("e")?, &true);
    assert_eq!(parser.find_val::<bool>("f")?, &true);

    Ok(())
}
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

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

Enable Flag option set style. It will support set style like --flag, but the value will be set to None.

Methods from Deref<Target = HCOptSet<P::Set, P::Inv<'a>, P::Ser>>§

source

pub fn invoker(&self) -> &Inv

source

pub fn invoker_mut(&mut self) -> &mut Inv

source

pub fn set_invoker(&mut self, inv: Inv) -> &mut Self

source

pub fn service(&self) -> &Ser

source

pub fn service_mut(&mut self) -> &mut Ser

source

pub fn set_service(&mut self, ser: Ser) -> &mut Self

source

pub fn optset(&self) -> &Set

source

pub fn optset_mut(&mut self) -> &mut Set

source

pub fn set_optset(&mut self, set: Set) -> &mut Self

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 app_data<T: ErasedTy>(&self) -> Result<&T, Error>

source

pub fn app_data_mut<T: ErasedTy>(&mut self) -> Result<&mut T, Error>

source

pub fn set_app_data<T: ErasedTy>(&mut self, val: T) -> Result<Option<T>, Error>

Set the value that can access in option handler.

Example 1

#[derive(Debug)]
struct Int(i64);

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

// Register a value can access in handler parameter.
parser.set_app_data(ser::Value::new(Int(42)))?;
parser.add_opt("--guess=i!")?.on(
  |_: &mut ASet, _: &mut ASer, mut val: ctx::Value<i64>, answer: ser::Value<Int>| {
      if &answer.0 == val.deref() {
          println!("Congratulation, you win!");
      } else if &answer.0 > val.deref() {
          println!("Oops, too bigger!")
      } else {
          println!("Oops, too little!")
      }
      Ok(Some(val.take()))
  },
)?;

getopt!(Args::from_array(["--guess", "42"]), &mut parser)?;
Example 2
#[derive(Debug)]
struct Int(i64);

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

// Register a value can access in handler parameter.
parser.set_app_data(Int(42))?;
parser.add_opt("--guess=i!")?.on(
  |_: &mut ASet, ser: &mut ASer, mut val: ctx::Value<i64>| {
      let answer = ser.sve_val::<Int>()?;

      if &answer.0 == val.deref() {
          println!("Congratulation, you win!");
      } else if &answer.0 > val.deref() {
          println!("Oops, too bigger!")
      } else {
          println!("Oops, too little!")
      }
      Ok(Some(val.take()))
  },
)?;

getopt!(Args::from_array(["--guess", "42"]), &mut parser)?;
source

pub fn add_opt( &mut self, opt: impl Into<Str> ) -> Result<ParserCommit<'a, '_, Inv, Set, Ser, Placeholder>, Error>

Add an option to the Set, return a ParserCommit.

Then you can modify the option configurations through the api of ParserCommit. Also you can call the function on, register option handler which will called when option set by user.

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

 // Add an option `--count` with type `i`.
 parser1.add_opt("--count=i")?;

 // Add an option `--len` with type `u`, and get its unique id.
 let _len_id = parser1.add_opt("--len=u")?.run()?;

 // Add an option `--size` with type `usize`, it has an alias `-s`.
 parser1.add_opt_i::<usize>("--size;-s")?;

 // Add an option `--path` with type `s`.
 // Set its value action to `Action::Set`.
 // The handler which add by `on` will called when option set.
 parser1
     .add_opt("--path=s")?
     .set_action(Action::Set)
     .on(|_: &mut ASet, _: &mut ASer, mut val: ctx::Value<String>| Ok(Some(val.take())))?;

 fn file_count_storer(
     uid: Uid,
     set: &mut ASet,
     _: &mut ASer,
     _: Option<&RawVal>,
     val: Option<bool>,
 ) -> Result<bool, Error> {
     let values = set[uid].entry::<u64>().or_insert(vec![0]);

     if let Some(is_file) = val {
         if is_file {
             values[0] += 1;

             return Ok(true);
         }
     }
     Ok(false)
 }
 // Add an NOA `file` with type `p`.
 // The handler which add by `on` will called when option set.
 // The `store` will called by `Invoker` when storing option value.
 parser1
     .add_opt("file=p@1..")?
     .on(|_: &mut ASet, _: &mut ASer, val: ctx::Value<String>| {
         let path = val.deref();

         if let Ok(meta) = std::fs::metadata(path) {
             if meta.is_file() {
                 println!("Got a file {:?}", path);
                 return Ok(Some(true));
             }
         }
         Ok(Some(false))
     })?
     .then(file_count_storer);

 getopt!(Args::from_array(["app", "foo", "-s", "10", "bar"]), &mut parser1)?;

 assert_eq!(parser1.find_val::<u64>("file=p")?, &0);
 assert_eq!(parser1.find_val::<usize>("--size")?, &10);
Examples found in repository?
examples/02_option_value.rs (line 7)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

pub fn main() -> Result<(), aopt::Error> {
    let mut parser = AFwdParser::default();

    // add option need argument with type `i`, i.e. i64
    parser.add_opt("-f=i")?;
    parser.add_opt("--flag=s")?;
    parser.add_opt_i::<f32>("-flag")?;

    parser
        .parse(ARef::new(Args::from(
            ["app", "-f42", "--flag", "foo", "-flag=2.1"].into_iter(),
        )))?
        .ok()?;

    assert_eq!(parser.find_val::<i64>("-f")?, &42);
    assert_eq!(parser.find_val::<String>("--flag")?, "foo");
    assert_eq!(parser.find_val::<f32>("-flag")?, &2.1);

    Ok(())
}
More examples
Hide additional examples
examples/04_positional.rs (line 6)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

pub fn main() -> Result<(), aopt::Error> {
    let mut parser = AFwdParser::default();

    parser.add_opt("--flag=b")?;
    parser.add_opt("--foo=s")?;
    // In default, positional has bool value
    parser.add_opt("first=p@1")?;
    // A special positional argument match the name, and force required
    parser.add_opt("list=c")?;
    // Add a positional argument has String value
    parser.add_opt_i::<Pos<String>>("second@2")?;

    // enable combination style
    parser.enable_combined();
    parser
        .parse(ARef::new(Args::from(
            ["app", "list", "--foo", "value", "bar"].into_iter(),
        )))?
        .ok()?;

    assert_eq!(parser.find_val::<bool>("list")?, &true);
    assert_eq!(parser.find_val::<bool>("first")?, &true);
    assert_eq!(parser.find_val::<String>("second")?, "bar");

    Ok(())
}
examples/01_prefix_option.rs (line 7)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

pub fn main() -> Result<(), aopt::Error> {
    let mut parser = AFwdParser::default();

    // add option with value type `b`, i.e. option with bool value or flag
    parser.add_opt("-f=b")?;
    parser.add_opt_i::<bool>("--flag")?;

    parser
        .parse(ARef::new(Args::from(["app", "-f"].into_iter())))?
        .ok()?;

    // option with bool type has default value `false`
    assert_eq!(parser.find_val::<bool>("-f")?, &true);
    assert_eq!(parser.find_val::<bool>("--flag")?, &false);

    parser.add_opt("-flag=b!")?;
    parser.add_opt("--/flag=b")?;

    parser
        .parse(ARef::new(Args::from(
            ["app", "-flag", "--/flag"].into_iter(),
        )))?
        .ok()?;

    // option with bool type has default value `false`
    assert_eq!(parser.find_val::<bool>("-flag")?, &true);
    assert_eq!(parser.find_val::<bool>("--/flag")?, &true);

    Ok(())
}
examples/03_combination_style.rs (line 7)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

pub fn main() -> Result<(), aopt::Error> {
    let mut parser = AFwdParser::default();

    // combination style only support bool type
    parser.add_opt("-a=b")?;
    parser.add_opt("-b=b")?;
    parser.add_opt_i::<bool>("-c")?;
    parser.add_opt("d=b")?;
    parser.add_opt("e=b")?;
    parser.add_opt_i::<bool>("f")?;

    // enable combination style
    parser.enable_combined();
    parser
        .parse(ARef::new(Args::from(["app", "-abc", "def"].into_iter())))?
        .ok()?;

    assert_eq!(parser.find_val::<bool>("-a")?, &true);
    assert_eq!(parser.find_val::<bool>("-b")?, &true);
    assert_eq!(parser.find_val::<bool>("-c")?, &true);
    assert_eq!(parser.find_val::<bool>("d")?, &false);
    assert_eq!(parser.find_val::<bool>("e")?, &false);
    assert_eq!(parser.find_val::<bool>("f")?, &false);

    // for support non-prefix option, need add prefix `""`,
    // and disable the strict flag of policy
    parser.validator_mut().add_prefix("");
    parser.set_strict(false);
    parser
        .parse(ARef::new(Args::from(["app", "-abc", "def"].into_iter())))?
        .ok()?;

    assert_eq!(parser.find_val::<bool>("-a")?, &true);
    assert_eq!(parser.find_val::<bool>("-b")?, &true);
    assert_eq!(parser.find_val::<bool>("-c")?, &true);
    assert_eq!(parser.find_val::<bool>("d")?, &true);
    assert_eq!(parser.find_val::<bool>("e")?, &true);
    assert_eq!(parser.find_val::<bool>("f")?, &true);

    Ok(())
}
source

pub fn add_opt_i<U>( &mut self, opt: impl Into<Str> ) -> Result<ParserCommit<'a, '_, Inv, Set, Ser, U>, Error>where U: Infer + 'static, U::Val: RawValParser,

Examples found in repository?
examples/02_option_value.rs (line 9)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

pub fn main() -> Result<(), aopt::Error> {
    let mut parser = AFwdParser::default();

    // add option need argument with type `i`, i.e. i64
    parser.add_opt("-f=i")?;
    parser.add_opt("--flag=s")?;
    parser.add_opt_i::<f32>("-flag")?;

    parser
        .parse(ARef::new(Args::from(
            ["app", "-f42", "--flag", "foo", "-flag=2.1"].into_iter(),
        )))?
        .ok()?;

    assert_eq!(parser.find_val::<i64>("-f")?, &42);
    assert_eq!(parser.find_val::<String>("--flag")?, "foo");
    assert_eq!(parser.find_val::<f32>("-flag")?, &2.1);

    Ok(())
}
More examples
Hide additional examples
examples/06_callback.rs (line 7)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

pub fn main() -> Result<(), aopt::Error> {
    let mut parser = AFwdParser::default();

    parser
        .add_opt_i::<i32>("-flag")?
        .on(|_: &mut ASet, _: &mut ASer| {
            println!("ignore the value set from command line");
            Ok(Some(42))
        })?;
    parser
        .add_opt_i::<bool>("--/flag")?
        .set_value(true)
        .on(|_: &mut ASet, _: &mut ASer, val: ctx::Value<bool>| Ok(Some(!*val)))?;

    parser
        .parse(ARef::new(Args::from(
            ["app", "-flag=foo", "--/flag"].into_iter(),
        )))?
        .ok()?;

    assert_eq!(parser.find_val::<i32>("-flag")?, &42);
    assert_eq!(parser.find_val::<bool>("--/flag")?, &false);

    Ok(())
}
examples/05_overload.rs (line 6)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

pub fn main() -> Result<(), aopt::Error> {
    let mut parser = AFwdParser::default();

    parser.add_opt_i::<i32>("-flag")?;
    parser.add_opt_i::<String>("-flag")?;
    parser.add_opt_i::<bool>("-flag")?;

    // enable combination style
    parser.set_overload(true);
    parser
        .parse(ARef::new(Args::from(
            ["app", "-flag=foo", "-flag=42", "-flag"].into_iter(),
        )))?
        .ok()?;

    assert_eq!(parser.find_i::<i32>("-flag")?.unwrap().val::<i32>()?, &42);
    assert_eq!(
        parser.find_i::<String>("-flag")?.unwrap().val::<String>()?,
        "foo"
    );
    assert_eq!(
        parser.find_i::<bool>("-flag")?.unwrap().val::<bool>()?,
        &true
    );

    Ok(())
}
examples/04_positional.rs (line 13)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

pub fn main() -> Result<(), aopt::Error> {
    let mut parser = AFwdParser::default();

    parser.add_opt("--flag=b")?;
    parser.add_opt("--foo=s")?;
    // In default, positional has bool value
    parser.add_opt("first=p@1")?;
    // A special positional argument match the name, and force required
    parser.add_opt("list=c")?;
    // Add a positional argument has String value
    parser.add_opt_i::<Pos<String>>("second@2")?;

    // enable combination style
    parser.enable_combined();
    parser
        .parse(ARef::new(Args::from(
            ["app", "list", "--foo", "value", "bar"].into_iter(),
        )))?
        .ok()?;

    assert_eq!(parser.find_val::<bool>("list")?, &true);
    assert_eq!(parser.find_val::<bool>("first")?, &true);
    assert_eq!(parser.find_val::<String>("second")?, "bar");

    Ok(())
}
examples/01_prefix_option.rs (line 8)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

pub fn main() -> Result<(), aopt::Error> {
    let mut parser = AFwdParser::default();

    // add option with value type `b`, i.e. option with bool value or flag
    parser.add_opt("-f=b")?;
    parser.add_opt_i::<bool>("--flag")?;

    parser
        .parse(ARef::new(Args::from(["app", "-f"].into_iter())))?
        .ok()?;

    // option with bool type has default value `false`
    assert_eq!(parser.find_val::<bool>("-f")?, &true);
    assert_eq!(parser.find_val::<bool>("--flag")?, &false);

    parser.add_opt("-flag=b!")?;
    parser.add_opt("--/flag=b")?;

    parser
        .parse(ARef::new(Args::from(
            ["app", "-flag", "--/flag"].into_iter(),
        )))?
        .ok()?;

    // option with bool type has default value `false`
    assert_eq!(parser.find_val::<bool>("-flag")?, &true);
    assert_eq!(parser.find_val::<bool>("--/flag")?, &true);

    Ok(())
}
examples/03_combination_style.rs (line 9)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

pub fn main() -> Result<(), aopt::Error> {
    let mut parser = AFwdParser::default();

    // combination style only support bool type
    parser.add_opt("-a=b")?;
    parser.add_opt("-b=b")?;
    parser.add_opt_i::<bool>("-c")?;
    parser.add_opt("d=b")?;
    parser.add_opt("e=b")?;
    parser.add_opt_i::<bool>("f")?;

    // enable combination style
    parser.enable_combined();
    parser
        .parse(ARef::new(Args::from(["app", "-abc", "def"].into_iter())))?
        .ok()?;

    assert_eq!(parser.find_val::<bool>("-a")?, &true);
    assert_eq!(parser.find_val::<bool>("-b")?, &true);
    assert_eq!(parser.find_val::<bool>("-c")?, &true);
    assert_eq!(parser.find_val::<bool>("d")?, &false);
    assert_eq!(parser.find_val::<bool>("e")?, &false);
    assert_eq!(parser.find_val::<bool>("f")?, &false);

    // for support non-prefix option, need add prefix `""`,
    // and disable the strict flag of policy
    parser.validator_mut().add_prefix("");
    parser.set_strict(false);
    parser
        .parse(ARef::new(Args::from(["app", "-abc", "def"].into_iter())))?
        .ok()?;

    assert_eq!(parser.find_val::<bool>("-a")?, &true);
    assert_eq!(parser.find_val::<bool>("-b")?, &true);
    assert_eq!(parser.find_val::<bool>("-c")?, &true);
    assert_eq!(parser.find_val::<bool>("d")?, &true);
    assert_eq!(parser.find_val::<bool>("e")?, &true);
    assert_eq!(parser.find_val::<bool>("f")?, &true);

    Ok(())
}
source

pub fn add_opt_cfg( &mut self, config: impl Into<SetCfg<Set>> ) -> Result<ParserCommit<'a, '_, Inv, Set, Ser, Placeholder>, Error>

Add an option to the Set, return a ParserCommit.

pub struct Bool;

impl From<Bool> for OptConfig {
    fn from(_: Bool) -> Self {
        OptConfig::default()
            .with_ctor("b")
            .with_type::<bool>()
            .with_styles(vec![Style::Boolean, Style::Combined])
            .with_action(Action::Set)
            .with_storer(ValStorer::fallback::<bool>())
            .with_ignore_index(true)
            .with_initializer(ValInitializer::new_value(false))
    }
}

pub struct Int64;

impl From<Int64> for OptConfig {
    fn from(_: Int64) -> Self {
        OptConfig::default()
            .with_ctor(ctor_default_name())
            .with_styles(vec![Style::Argument])
            .with_type::<i64>()
            .with_action(Action::Set)
            .with_storer(ValStorer::fallback::<i64>())
            .with_ignore_index(true)
            .with_initializer(ValInitializer::new_value(0i64))
    }
}

    let mut parser = AFwdParser::default();

    parser.add_opt_cfg(Bool)?.set_name("--round");
    parser.add_opt_cfg(Int64)?.set_name("--poll");

    parser.parse(aopt::ARef::new(Args::from(["--poll", "42"].into_iter())))?;

    assert_eq!(parser.find_val::<bool>("--round")?, &false);
    assert_eq!(parser.find_val::<i64>("--poll")?, &42);
source

pub fn add_opt_cfg_i<U>( &mut self, config: impl Into<SetCfg<Set>> ) -> Result<ParserCommit<'a, '_, Inv, Set, Ser, U>, Error>where U: Infer + 'static, U::Val: RawValParser,

source

pub fn entry<A, O, H>( &mut self, uid: Uid ) -> Result<HandlerEntry<'a, '_, Inv, Set, Ser, H, A, O>, Error>where O: ErasedTy, H: Handler<Set, Ser, A, Output = Option<O>, Error = Error> + 'a, A: Extract<Set, Ser, Error = Error> + 'a,

Trait Implementations§

source§

impl<'a, P: Debug + Policy> Debug for Parser<'a, P>where P::Set: Debug, P::Inv<'a>: Debug, P::Ser: Debug,

source§

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

Formats the value using the given formatter. Read more
source§

impl<'a, P: Default + Policy> Default for Parser<'a, P>where P::Set: Default, P::Inv<'a>: Default, P::Ser: Default,

source§

fn default() -> Parser<'a, P>

Returns the “default value” for a type. Read more
source§

impl<'a, P: Policy> Deref for Parser<'a, P>

§

type Target = HCOptSet<<P as Policy>::Set, <P as Policy>::Inv<'a>, <P as Policy>::Ser>

The resulting type after dereferencing.
source§

fn deref(&self) -> &Self::Target

Dereferences the value.
source§

impl<'a, P: Policy> DerefMut for Parser<'a, P>

source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
source§

impl<'a, P: Policy> PolicyParser<P> for Parser<'a, P>where P::Set: Set,

§

type Error = Error

source§

fn parse(&mut self, args: ARef<Args>) -> Result<<P as Policy>::Ret, Self::Error>where P: Default,

source§

fn parse_policy( &mut self, args: ARef<Args>, policy: &mut P ) -> Result<<P as Policy>::Ret, Self::Error>

source§

fn parse_env_policy(&mut self, policy: &mut P) -> Result<P::Ret, Self::Error>

source§

impl<'a, P> PolicySettings for Parser<'a, P>where P: Policy + PolicySettings,

source§

fn style_manager(&self) -> &OptStyleManager

source§

fn style_manager_mut(&mut self) -> &mut OptStyleManager

source§

fn strict(&self) -> bool

source§

fn styles(&self) -> &[UserStyle]

source§

fn no_delay(&self) -> Option<&[Str]>

source§

fn overload(&self) -> bool

source§

fn set_strict(&mut self, strict: bool) -> &mut Self

source§

fn set_styles(&mut self, styles: Vec<UserStyle>) -> &mut Self

source§

fn set_no_delay(&mut self, name: impl Into<Str>) -> &mut Self

source§

fn set_overload(&mut self, overload: bool) -> &mut Self

Auto Trait Implementations§

§

impl<'a, P> RefUnwindSafe for Parser<'a, P>where P: RefUnwindSafe, <P as Policy>::Inv<'a>: RefUnwindSafe, <P as Policy>::Ser: RefUnwindSafe, <P as Policy>::Set: RefUnwindSafe,

§

impl<'a, P> Send for Parser<'a, P>where P: Send, <P as Policy>::Inv<'a>: Send, <P as Policy>::Ser: Send, <P as Policy>::Set: Send,

§

impl<'a, P> Sync for Parser<'a, P>where P: Sync, <P as Policy>::Inv<'a>: Sync, <P as Policy>::Ser: Sync, <P as Policy>::Set: Sync,

§

impl<'a, P> Unpin for Parser<'a, P>where P: Unpin, <P as Policy>::Inv<'a>: Unpin, <P as Policy>::Ser: Unpin, <P as Policy>::Set: Unpin,

§

impl<'a, P> UnwindSafe for Parser<'a, P>where P: UnwindSafe, <P as Policy>::Inv<'a>: UnwindSafe, <P as Policy>::Ser: UnwindSafe, <P as Policy>::Set: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T> ErasedTy for Twhere T: Any + 'static,