Struct aopt::parser::PrePolicy

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

PrePolicy matching the command line arguments with Opt in the Set. PrePolicy will skip any special Error during parse process. PrePolicy will return Some(ReturnVal) if match successful. PrePolicy doesn’t consume the NOA when process guess_and_invoke.

Example

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

parser
    .add_opt("-check=s")?
    .on(|set: &mut ASet, _: &mut ASer, ext: ctx::Value<String>| {
        let mut found = false;

        for name in ["-c", "-cxx"] {
            if let Ok(opt) = set.find(name) {
                if let Ok(file) = opt.vals::<String>() {
                    if file.contains(ext.deref()) {
                        found = true;
                    }
                }
            }
        }
        Ok(Some(found))
    })?;
cfg_loader.set_app_data(parser)?;
cfg_loader.add_opt("--load=s")?.on(
    |_: &mut ASet, ser: &mut ASer, mut cfg: ctx::Value<String>| {
        let parser = ser.sve_val_mut::<AFwdParser>()?;

        match cfg.as_str() {
            "cxx" => {
                parser.add_opt("-cxx".infer::<String>())?.set_values(
                    ["cxx", "cpp", "c++", "cc", "hpp", "hxx", "h"]
                        .map(|v| v.to_owned())
                        .to_vec(),
                );
            }
            "c" => {
                parser
                    .add_opt("-c=s")?
                    .set_values_t(["c", "h"].map(|v| v.to_owned()).to_vec());
            }
            _ => {
                panic!("Unknow configuration name")
            }
        }

        Ok(Some(cfg.take()))
    },
)?;

let ret = getopt!(
    Args::from(["--load", "cxx", "-check", "cc"]),
    &mut cfg_loader
)?;
let next_args = ret.ret.clone_args();
let mut parser = cfg_loader.service_mut().sve_take_val::<AFwdParser>()?;

getopt!(Args::from(next_args), &mut parser)?;

assert!(*parser.find_val::<bool>("-check")?);

// pass the parser to AppService
cfg_loader.set_app_data(parser)?;

let ret = getopt!(
    Args::from(["--load", "c", "-check", "c"]),
    &mut cfg_loader
)?;
let next_args = ret.ret.clone_args();
let mut parser = cfg_loader.service_mut().sve_take_val::<AFwdParser>()?;

getopt!(Args::from(next_args), &mut parser)?;

assert!(*parser.find_val::<bool>("-check")?);

Implementations

impl<Set, Ser, Chk> PrePolicy<Set, Ser, Chk>

where Chk: Default,

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

impl<Set, Ser, Chk> PrePolicy<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, otherwise it will be discarded.

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

pub fn ig_failure<T: Default>(res: Result<T, Error>) -> Result<Option<T>, Error>

Ignore failure when parsing.

Trait Implementations

impl<Set, Ser, Chk> APolicyExt<PrePolicy<Set, Ser, Chk>> for PrePolicy<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) -> <PrePolicy<Set, Ser, Chk> as Policy>::Inv<'a>

impl<Set, Ser, Chk> Clone for PrePolicy<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 PrePolicy<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 PrePolicy<Set, Ser, Chk>

where Chk: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<Set, Ser, Chk> Policy for PrePolicy<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 PrePolicy<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