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(["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>,
impl<'a, P> Parser<'a, P>where
P: Policy + APolicyExt<P>,
pub fn new_policy(policy: P) -> Self
source§impl<'a, P: Policy> Parser<'a, P>
impl<'a, P: Policy> Parser<'a, P>
pub fn new( policy: P, optset: HCOptSet<<P as Policy>::Set, <P as Policy>::Inv<'a>, <P as Policy>::Ser> ) -> Self
pub fn new_with( policy: P, optset: P::Set, invoker: P::Inv<'a>, valser: P::Ser ) -> Self
pub fn policy(&self) -> &P
pub fn policy_mut(&mut self) -> &mut P
pub fn set_policy(&mut self, policy: P) -> &mut Self
pub fn optset(&self) -> &HCOptSet<P::Set, P::Inv<'a>, P::Ser>
pub fn optset_mut(&mut self) -> &mut HCOptSet<P::Set, P::Inv<'a>, P::Ser>
pub fn set_optset( &mut self, optset: HCOptSet<P::Set, P::Inv<'a>, P::Ser> ) -> &mut Self
source§impl<'a, P> Parser<'a, P>
impl<'a, P> Parser<'a, P>
sourcepub fn parse(&mut self, args: ARef<Args>) -> Result<<P as Policy>::Ret, Error>
pub fn parse(&mut self, args: ARef<Args>) -> Result<<P as Policy>::Ret, Error>
Examples found in repository?
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("-flag".infer::<f32>())?;
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
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
pub fn main() -> Result<(), aopt::Error> {
let mut parser = AFwdParser::default();
parser.add_opt("-flag".infer::<i32>())?;
parser.add_opt("-flag".infer::<String>())?;
parser.add_opt("-flag".infer::<bool>())?;
// 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("-flag".infer::<i32>())?.val::<i32>()?, &42);
assert_eq!(
parser.find("-flag".infer::<String>())?.val::<String>()?,
"foo"
);
assert_eq!(parser.find("-flag".infer::<bool>())?.val::<bool>()?, &true);
Ok(())
}
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("-flag".infer::<i32>())?
.on(|_: &mut ASet, _: &mut ASer| {
println!("ignore the value set from command line");
Ok(Some(42))
})?;
parser
.add_opt("--/flag".infer::<bool>())?
.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(())
}
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("second@2".infer::<Pos<String>>())?;
// 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(())
}
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("--flag".infer::<bool>())?;
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(())
}
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("-c".infer::<bool>())?;
parser.add_opt("d=b")?;
parser.add_opt("e=b")?;
parser.add_opt("f".infer::<bool>())?;
// 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,
impl<'a, P> Parser<'a, P>where
P: Policy + PolicySettings,
sourcepub fn enable_combined(&mut self) -> &mut Self
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?
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("second@2".infer::<Pos<String>>())?;
// 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
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("-c".infer::<bool>())?;
parser.add_opt("d=b")?;
parser.add_opt("e=b")?;
parser.add_opt("f".infer::<bool>())?;
// 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(())
}
sourcepub fn enable_embedded_plus(&mut self) -> &mut Self
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
.
sourcepub fn enable_flag(&mut self) -> &mut Self
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>>§
pub fn invoker(&self) -> &Inv
pub fn invoker_mut(&mut self) -> &mut Inv
pub fn set_invoker(&mut self, inv: Inv) -> &mut Self
pub fn service(&self) -> &Ser
pub fn service_mut(&mut self) -> &mut Ser
pub fn set_service(&mut self, ser: Ser) -> &mut Self
pub fn optset(&self) -> &Set
pub fn optset_mut(&mut self) -> &mut Set
pub fn set_optset(&mut self, set: Set) -> &mut Self
pub fn app_data<T: ErasedTy>(&self) -> Result<&T, Error>
pub fn app_data_mut<T: ErasedTy>(&mut self) -> Result<&mut T, Error>
sourcepub fn set_app_data<T: ErasedTy>(&mut self, val: T) -> Result<Option<T>, Error>
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, ctx::Value(val), answer: ser::Value<Int>| {
match answer.deref().0.cmp(&val) {
std::cmp::Ordering::Equal => println!("Congratulation, you win!"),
std::cmp::Ordering::Greater => println!("Oops, too bigger!"),
std::cmp::Ordering::Less => println!("Oops, too little!"),
}
Ok(Some(val))
},
)?;
getopt!(Args::from(["--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(["--guess", "42"]), &mut parser)?;
sourcepub fn add_opt<B>(
&mut self,
cb: B
) -> Result<ParserCommit<'a, '_, Inv, Set, Ser, B::Val>, Error>
pub fn add_opt<B>( &mut self, cb: B ) -> Result<ParserCommit<'a, '_, Inv, Set, Ser, B::Val>, 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("--size;-s".infer::<usize>())?;
// 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(["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?
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("-flag".infer::<f32>())?;
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
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
pub fn main() -> Result<(), aopt::Error> {
let mut parser = AFwdParser::default();
parser.add_opt("-flag".infer::<i32>())?;
parser.add_opt("-flag".infer::<String>())?;
parser.add_opt("-flag".infer::<bool>())?;
// 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("-flag".infer::<i32>())?.val::<i32>()?, &42);
assert_eq!(
parser.find("-flag".infer::<String>())?.val::<String>()?,
"foo"
);
assert_eq!(parser.find("-flag".infer::<bool>())?.val::<bool>()?, &true);
Ok(())
}
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("-flag".infer::<i32>())?
.on(|_: &mut ASet, _: &mut ASer| {
println!("ignore the value set from command line");
Ok(Some(42))
})?;
parser
.add_opt("--/flag".infer::<bool>())?
.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(())
}
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("second@2".infer::<Pos<String>>())?;
// 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(())
}
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("--flag".infer::<bool>())?;
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(())
}
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("-c".infer::<bool>())?;
parser.add_opt("d=b")?;
parser.add_opt("e=b")?;
parser.add_opt("f".infer::<bool>())?;
// 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(())
}
sourcepub fn add_opt_cfg(
&mut self,
config: impl Into<SetCfg<Set>>
) -> Result<ParserCommit<'a, '_, Inv, Set, Ser, Placeholder>, Error>
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_style(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_style(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);