fn parse()

in resctl-bench/src/bench/protection.rs [137:185]
49 lines of code
10 McCabe index (conditional complexity)

    fn parse(mut props: BTreeMap<String, String>) -> Result<Self> {
        match props.remove("scenario").as_deref() {
            Some("mem-hog") => {
                let mut hog = MemHog::default();
                for (k, v) in props.iter() {
                    match k.as_str() {
                        "loops" => hog.loops = v.parse::<u32>()?,
                        "load" => hog.load = parse_frac(v)?,
                        "speed" => hog.speed = MemHogSpeed::from_str(v)?,
                        k => bail!("unknown mem-hog property {:?}", k),
                    }
                }
                if hog.loops == 0 || hog.load == 0.0 {
                    bail!("\"loops\" and \"load\" can't be 0");
                }
                Ok(Self::MemHog(hog))
            }
            Some("mem-hog-tune") => {
                let mut tune = MemHogTune::default();
                for (k, v) in props.iter() {
                    match k.as_str() {
                        "load" => tune.load = parse_frac(v)?,
                        "speed" => tune.speed = MemHogSpeed::from_str(v)?,
                        "size-min" => tune.size_range.0 = parse_size(v)? as usize,
                        "size-max" => tune.size_range.1 = parse_size(v)? as usize,
                        "intvs" => tune.intvs = v.parse::<u32>()?,
                        "isol-pct" => tune.isol_pct = v.to_owned(),
                        "isol-thr" => tune.isol_thr = parse_frac(v)?,
                        k => bail!("unknown mem-hog-tune property {:?}", k),
                    }
                }
                if tune.load == 0.0 || tune.intvs == 0 {
                    bail!("\"load\" and \"intvs\" can't be 0");
                }
                if tune.size_range.1 == 0 || tune.size_range.1 < tune.size_range.0 {
                    bail!("Invalid size range");
                }
                if !MemHog::PCTS.contains(&tune.isol_pct.as_str()) {
                    bail!(
                        "Invalid isol-pct {:?}, supported: {:?}",
                        &tune.isol_pct,
                        &MemHog::PCTS
                    );
                }
                Ok(Self::MemHogTune(tune))
            }
            _ => bail!("\"scenario\" invalid or missing"),
        }
    }