Method from_str

src/parse.rs:9–34

(value: &str)

    type Err = String;

    fn from_str(value: &str) -> Result<Self, Self::Err> {
        if let Ok(v) = value.parse::<u64>() {
            return Ok(Self(v));
        }
        let number = take_while(value, |c| c.is_ascii_digit() || c == '.');
        match number.parse::<f64>() {
            Ok(v) => {
                let suffix = skip_while(&value[number.len()..], char::is_whitespace);
                match suffix.parse::<Unit>() {
                    // Use exact integer arithmetic when the number has no
                    // fractional part. `f64` only has a 53-bit mantissa, so byte
                    // counts at or above 2^53 would otherwise be rounded (e.g.
                    // "9007199254740993B" parsed to 9007199254740992).
                    Ok(u) if !number.contains('.') => match number.parse::<u64>() {
                        Ok(n) => Ok(Self(n.saturating_mul(u.factor()))),
                        Err(_) => Ok(Self((v * u) as u64)),
                    },
                    Ok(u) => Ok(Self((v * u) as u64)),
                    Err(error) => Err(format!(
                        "couldn't parse {suffix:?} into a known SI unit, {error}"
                    )),
                }
            }
            Err(error) => Err(format!("couldn't parse {value:?} into a ByteSize, {error}")),
        }
    }
}

fn take_while<P>(s: &str, mut predicate: P) -> &str