Struct cmdopts::OptConstr

pub struct OptConstr(_);

Option constraints.

Mutable reference to an OptConstr object is passed to the opt_i() hander to provide ability to define additional constraints on a parsed option. The handler should call OptConstr public methods for the object to specify required constraints or remain the object untouched if no constraints are required.

Implementations

impl OptConstr

pub fn not_in_group(&mut self)

Option may not occur inside a group. Applies only for short options.

Examples found in repository

examples/advanced.rs (line 100)

fn process_cmdopts(opts: &mut Options) -> Result<(), ParseError>
{
    use CmdOpt::*;
    use InfoCode::*;
    use ProcessCode::*;
    use ParseError::*;
    use OptId::*;
    use std::cell::Cell;

    #[derive(Clone)]
    #[derive(Copy)]
    enum OptId {
        OptA,
        OptB,
        OptC,
        OptD,
        OptE,
        OptHelp,
        OptSwitch,
    }
    impl Default for OptId { fn default() -> Self { OptHelp } }

    // processed option id
    let opt_id: Cell<OptId> = Default::default();

    // file parsing index (1-based), 0 for option parsing mode
    let mut file_i = 0;

    parse_opts(
        |opt, constr| {
            match opt {
                Short(c) => {
                    match c {
                        'a' => { opt_id.set(OptA); NoValueOpt },
                        'b' => { opt_id.set(OptB); ValueOpt },
                        'c' => { opt_id.set(OptC); ValueOpt },
                        'd' => { opt_id.set(OptD); ValueOpt },
                        'h' => { opt_id.set(OptHelp); NoValueOpt },
                        '-' => {
                            constr.not_in_group();
                            opt_id.set(OptSwitch);
                            NoValueOpt
                        },
                        _ => InfoCode::InvalidOpt,
                    }
                },
                Long(s) => {
                    match s.as_str() {
                        "long_a" => { opt_id.set(OptA); NoValueOpt },
                        "long_b" => { opt_id.set(OptB); ValueOpt },
                        "long_c" => { opt_id.set(OptC); ValueOpt },
                        "long_e" => { opt_id.set(OptE); ValueOpt },
                        "help" => { opt_id.set(OptHelp); NoValueOpt },
                        _ => InfoCode::InvalidOpt,
                    }
                },
            }
        },

        |opt, val| {
            // if true, mode needs to be switched at the return of the handler
            let mut switch_mode = false;

            // 1st standalone value switches the parser into files parsing mode
            if file_i <= 0 && opt.is_none() {
                file_i = 1;
                switch_mode = true;
            }

            if file_i <= 0 {
                //
                // Options parser
                //

                // Options w/o associated value
                //
                let mut handled = true;

                match opt_id.get() {
                    // print help and exit
                    OptHelp => {
                        opts.help = Some(());
                        return Ok(ProcessCode::Break);
                    },
                    OptSwitch => {
                        file_i = 1;
                        return Ok(ProcessCode::ToggleParsingMode);
                    },
                    OptA => {
                        opts.a_opt = Some(());
                    },
                    _ => {
                        handled = false;
                    },
                }
                if handled {
                    return Ok(ProcessCode::Continue);
                }

                // Options w/associated string value
                //
                let val_str = &val.as_ref().unwrap().val;
                handled = true;

                match opt_id.get() {
                    OptC => {
                        opts.c_opt = Some(val_str.clone());
                    },
                    OptD => {
                        opts.d_opt = Some(val_str.clone());
                    },
                    OptE => {
                        opts.e_opt = Some(val_str.clone());
                    },
                    _ => {
                        handled = false;
                    },
                }
                if handled {
                    return Ok(ProcessCode::Continue);
                }

                // Options w/associated int value
                //
                let opt_ref = opt.as_ref().unwrap();

                let val_i: i32 = val_str.parse().map_err(|_| {
                    ParseError::InvalidOpt(opt_ref.clone(),
                        "Integer expected".to_string())
                })?;

                match opt_id.get() {
                    OptB => {
                        if val_i >= -10 && val_i <= 10 {
                            opts.b_opt = Some(val_i);
                        } else {
                            return Err(ParseError::InvalidOpt(opt_ref.clone(),
                                "Integer in range [-10..10] required".to_string()));
                        }
                    },
                    _ => {},
                }

                Ok(ProcessCode::Continue)
            } else {
                //
                // Files parser
                //
                let val_str = &val.as_ref().unwrap().val;

                match file_i {
                    1 => {
                        opts.file1 = Some(val_str.clone());
                    },
                    2 => {
                        opts.file2 = Some(val_str.clone());
                    },
                    _ => {
                        return Err(ParseError::GenericErr(
                            "Invalid number of files".to_string()));
                    },
                }
                file_i += 1;

                if switch_mode {
                    Ok(ToggleParsingMode)
                } else {
                    Ok(Continue)
                }
            }
        })
}

Trait Implementations

impl Default for OptConstr

fn default() -> Self

Returns the “default value” for a type.