Struct aopt::parser::FwdPolicy

pub struct FwdPolicy<Set, Ser, Chk> { /* private fields */ }

FwdPolicy matching the command line arguments with Opt in the Set. The option would match failed if any special Error raised during option processing. FwdPolicy will return Some(ReturnVal) if match successful. FwdPolicy process the option before any NOA(Cmd, Pos and Main). During parsing, you can get the value of any option in the handler of NOA.

Examples

let mut policy = AFwdPolicy::default();
let mut set = policy.default_set();
let mut inv = policy.default_inv();
let mut ser = policy.default_ser();
let filter_id = set.add_opt("--/filter=b")?.run()?;
let pos_id = set.add_opt("pos=p@*")?
                .set_pos_type::<String>()
                .set_values(vec![])
                .run()?;

inv.entry(pos_id).on(
    move |set: &mut ASet,
            _: &mut ASer,
            filter: ser::Value<Vec<&str>>,
            mut value: ctx::Value<String>| {
        let not_filter = set[filter_id].val::<bool>()?;
        let valid = if !*not_filter {
            !filter.iter().any(|&v| v == value.as_str())
        } else {
            true
        };

        Ok(valid.then(|| value.take()))
    },
);

let args = Args::from(["app", "set", "42", "foo", "bar"]);

for opt in set.iter_mut() {
    opt.init()?;
}
ser.sve_insert(ser::Value::new(vec!["foo", "bar"]));
policy.parse(&mut set, &mut inv, &mut ser, ARef::new(args))?;

let values = set[pos_id].vals::<String>()?;

assert_eq!(values[0], "set");
assert_eq!(values[1], "42");

let args = Args::from(["app", "--/filter", "set", "42", "foo", "bar"]);

for opt in set.iter_mut() {
    opt.init()?;
}

policy.parse(&mut set, &mut inv, &mut ser, ARef::new(args))?;
let values = set[pos_id].vals::<String>()?;

assert_eq!(values[0], "set");
assert_eq!(values[1], "42");
assert_eq!(values[2], "foo");
assert_eq!(values[3], "bar");

Implementations

impl<Set, Ser, Chk> FwdPolicy<Set, Ser, Chk>

where Chk: Default,

pub fn new(strict: bool, style: OptStyleManager) -> Self

impl<Set, Ser, Chk> FwdPolicy<Set, Ser, Chk>

pub fn with_strict(self, strict: bool) -> Self

In strict mode, if an argument looks like an option (it matched any option prefix), then it must matched.

pub fn with_styles(self, styles: Vec<UserStyle>) -> Self

pub fn with_checker(self, checker: Chk) -> Self

pub fn with_overload(self, overload: bool) -> Self

pub fn set_checker(&mut self, checker: Chk) -> &mut Self

pub fn checker(&self) -> &Chk

pub fn checker_mut(&mut self) -> &mut Chk

Trait Implementations

impl<Set, Ser, Chk> APolicyExt<FwdPolicy<Set, Ser, Chk>> for FwdPolicy<Set, Ser, Chk>

where Ser: Default, Chk: SetChecker<Set>, Set: Set + OptParser + OptValidator + Default,

fn default_set(&self) -> Set

fn default_ser(&self) -> Ser

fn default_inv<'a>(&self) -> <FwdPolicy<Set, Ser, Chk> as Policy>::Inv<'a>

impl<Set, Ser, Chk> Clone for FwdPolicy<Set, Ser, Chk>

where Chk: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Set, Ser, Chk> Debug for FwdPolicy<Set, Ser, Chk>

where Chk: Debug,

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

Formats the value using the given formatter.

impl<Set, Ser, Chk> Default for FwdPolicy<Set, Ser, Chk>

where Chk: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<Set, Ser, Chk> Policy for FwdPolicy<Set, Ser, Chk>

where SetOpt<Set>: Opt, Chk: SetChecker<Set>, Set: Set + OptParser + OptValidator,

type Ret = ReturnVal

type Set = Set

type Inv<'a> = Invoker<'a, Set, Ser>

type Ser = Ser

type Error = Error

fn parse( &mut self, set: &mut Self::Set, inv: &mut Self::Inv<'_>, ser: &mut Self::Ser, args: ARef<Args> ) -> Result<Self::Ret, Self::Error>

impl<Set, Ser, Chk> PolicySettings for FwdPolicy<Set, Ser, Chk>

fn style_manager(&self) -> &OptStyleManager

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

fn strict(&self) -> bool

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

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

fn overload(&self) -> bool

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

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

fn set_no_delay(&mut self, _: impl Into<AStr>) -> &mut Self

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