102 lines
3.6 KiB
Rust
102 lines
3.6 KiB
Rust
use {
|
|
crate::utils::errorfmt::ErrorFmt,
|
|
std::{collections::VecDeque, str::FromStr, time::Duration},
|
|
};
|
|
|
|
#[derive(Debug)]
|
|
enum Component {
|
|
Number(u64),
|
|
Minutes(String),
|
|
Seconds(String),
|
|
Milliseconds(String),
|
|
}
|
|
|
|
pub fn parse_duration(args: &[String]) -> Duration {
|
|
let comp = parse_components(args);
|
|
let mut minutes = None;
|
|
let mut seconds = None;
|
|
let mut milliseconds = None;
|
|
let mut pending_num = None;
|
|
for comp in comp {
|
|
match comp {
|
|
Component::Number(_) if pending_num.is_some() => {
|
|
fatal!("missing number unit after {}", pending_num.unwrap())
|
|
}
|
|
Component::Number(n) => pending_num = Some(n),
|
|
|
|
Component::Minutes(n) if pending_num.is_none() => {
|
|
fatal!("`{}` must be preceded by a number", n)
|
|
}
|
|
Component::Minutes(_) if minutes.is_some() => {
|
|
fatal!("minutes specified multiple times")
|
|
}
|
|
Component::Minutes(_) => minutes = pending_num.take(),
|
|
|
|
Component::Seconds(n) if pending_num.is_none() => {
|
|
fatal!("`{}` must be preceded by a number", n)
|
|
}
|
|
Component::Seconds(_) if seconds.is_some() => {
|
|
fatal!("seconds specified multiple times")
|
|
}
|
|
Component::Seconds(_) => seconds = pending_num.take(),
|
|
Component::Milliseconds(n) if pending_num.is_none() => {
|
|
fatal!("`{}` must be preceded by a number", n)
|
|
}
|
|
Component::Milliseconds(_) if milliseconds.is_some() => {
|
|
fatal!("milliseconds specified multiple times")
|
|
}
|
|
Component::Milliseconds(_) => milliseconds = pending_num.take(),
|
|
}
|
|
}
|
|
if pending_num.is_some() {
|
|
fatal!("missing number unit after {}", pending_num.unwrap());
|
|
}
|
|
if minutes.is_none() && seconds.is_none() && milliseconds.is_none() {
|
|
fatal!("duration must be specified");
|
|
}
|
|
let mut ms = minutes.unwrap_or(0) as u128 * 60 * 1000
|
|
+ seconds.unwrap_or(0) as u128 * 1000
|
|
+ milliseconds.unwrap_or(0) as u128;
|
|
if ms > u64::MAX as u128 {
|
|
ms = u64::MAX as u128;
|
|
}
|
|
Duration::from_millis(ms as u64)
|
|
}
|
|
|
|
fn parse_components(args: &[String]) -> Vec<Component> {
|
|
let mut args = VecDeque::from_iter(args.iter().map(|s| s.to_ascii_lowercase()));
|
|
let mut res = vec![];
|
|
while let Some(arg) = args.pop_front() {
|
|
if arg.is_empty() {
|
|
continue;
|
|
}
|
|
let mut arg = &arg[..];
|
|
if is_num(arg.as_bytes()[0]) {
|
|
if let Some(pos) = arg.as_bytes().iter().position(|&a| !is_num(a)) {
|
|
args.push_front(arg[pos..].to_string());
|
|
arg = &arg[..pos];
|
|
}
|
|
match u64::from_str(arg) {
|
|
Ok(n) => res.push(Component::Number(n)),
|
|
Err(e) => fatal!("Could not parse `{}` as a number: {}", arg, ErrorFmt(e)),
|
|
}
|
|
} else {
|
|
if let Some(pos) = arg.as_bytes().iter().position(|&a| is_num(a)) {
|
|
args.push_front(arg[pos..].to_string());
|
|
arg = &arg[..pos];
|
|
}
|
|
let comp = match arg {
|
|
"minutes" | "minute" | "min" | "m" => Component::Minutes(arg.to_string()),
|
|
"seconds" | "second" | "sec" | "s" => Component::Seconds(arg.to_string()),
|
|
"milliseconds" | "millisecond" | "ms" => Component::Milliseconds(arg.to_string()),
|
|
_ => fatal!("Could not parse `{}`", arg),
|
|
};
|
|
res.push(comp);
|
|
}
|
|
}
|
|
res
|
|
}
|
|
|
|
fn is_num(b: u8) -> bool {
|
|
matches!(b, b'0'..=b'9')
|
|
}
|