use crate::{Error, Result};
use super::exact::{DurationTiers, ExactAccumulator};
use super::{
range_err, DurationField, Temporal, MONTHS_PER_YEAR, NANOS_PER_HOUR, NANOS_PER_MINUTE,
NANOS_PER_SECOND,
};
pub(super) fn parse_duration_iso(s: &str) -> Result<Temporal> {
let raw = s.trim();
let (neg, body) = match raw.strip_prefix('-') {
Some(rest) => (true, rest),
None => (false, raw.strip_prefix('+').unwrap_or(raw)),
};
let folded = body.to_ascii_uppercase();
let Some(body) = folded.strip_prefix('P') else {
return Err(Error::ty(format!("cannot parse duration '{s}'")));
};
let (date, time) = match body.find('T') {
Some(at) if at + 1 == body.len() => return Err(Error::ty("invalid duration time")),
Some(at) => (&body[..at], Some(&body[at + 1..])),
None => (body, None),
};
if date.is_empty() && time.is_none() {
return Err(Error::ty("invalid duration component"));
}
let mut tiers = DurationTiers::default();
if is_datetime_style_duration(date, time) {
parse_duration_datetime_style(date, time, &mut tiers)?;
} else {
let mut fractional = false;
parse_duration_part(date, Part::Date, &mut tiers, &mut fractional)?;
if let Some(t) = time {
parse_duration_part(t, Part::Time, &mut tiers, &mut fractional)?;
}
}
let (mut months, mut days, mut nanos) = tiers.finish()?;
if neg {
months = months.checked_neg().ok_or_else(range_err)?;
days = days.checked_neg().ok_or_else(range_err)?;
nanos = nanos.checked_neg().ok_or_else(range_err)?;
}
Temporal::duration_checked_exact(months, days, nanos)
}
#[derive(Clone, Copy)]
enum Part {
Date,
Time,
}
struct Component {
whole: i128,
frac: f64,
unit: char,
decimal: bool,
}
struct ComponentScanner<'a> {
chars: std::str::Chars<'a>,
num: String,
sign: i64,
}
impl<'a> ComponentScanner<'a> {
fn new(s: &'a str) -> Self {
Self {
chars: s.chars(),
num: String::new(),
sign: 1,
}
}
fn next_component(&mut self) -> Result<Option<Component>> {
for c in self.chars.by_ref() {
if c == '-' && self.num.is_empty() {
if self.sign == -1 {
return Err(Error::ty("invalid duration component"));
}
self.sign = -1;
continue;
}
if c.is_ascii_digit() || c == '.' {
self.num.push(c);
continue;
}
if self.num.is_empty() {
return Err(Error::ty("invalid duration component"));
}
let (whole, frac) = split_duration_numeral(&self.num)?;
let decimal = self.num.contains('.');
self.num.clear();
let whole = whole
.checked_mul(i128::from(self.sign))
.ok_or_else(range_err)?;
let frac = frac * self.sign as f64;
self.sign = 1;
return Ok(Some(Component {
whole,
frac,
unit: c,
decimal,
}));
}
if !self.num.is_empty() || self.sign != 1 {
return Err(Error::ty("invalid duration component"));
}
Ok(None)
}
}
fn parse_duration_part(
s: &str,
part: Part,
tiers: &mut DurationTiers,
fractional: &mut bool,
) -> Result<()> {
let mut scanner = ComponentScanner::new(s);
while let Some(component) = scanner.next_component()? {
if *fractional {
return Err(Error::argument_error(
"Text cannot be parsed to a Duration: a decimal is only allowed in the last component",
));
}
*fractional = component.decimal;
let field = match (component.unit, part) {
('Y', Part::Date) => DurationField::Years,
('M', Part::Date) => DurationField::Months,
('W', Part::Date) => DurationField::Weeks,
('D', Part::Date) => DurationField::Days,
('H', Part::Time) => DurationField::Hours,
('M', Part::Time) => DurationField::Minutes,
('S', Part::Time) => DurationField::Seconds,
_ => return Err(Error::ty("invalid duration component")),
};
let (accumulator, scale) = field.scaled(tiers);
accumulator.add_unit(component.whole, component.frac, scale)?;
}
Ok(())
}
pub(super) fn split_duration_numeral(num: &str) -> Result<(i128, f64)> {
let (whole, frac) = num.split_once('.').unwrap_or((num, ""));
let whole = if whole.is_empty() {
0
} else {
whole.parse::<i128>().map_err(|_| range_err())?
};
let frac = if frac.is_empty() {
0.0
} else {
format!("0.{frac}")
.parse::<f64>()
.map_err(|_| Error::ty("invalid duration component"))?
};
Ok((whole, frac))
}
fn metadata_style(s: &str, sep: char) -> bool {
s.contains(sep)
&& s.chars()
.all(|c| c.is_ascii_digit() || c == sep || c == '.')
}
fn is_datetime_style_duration(date: &str, time: Option<&str>) -> bool {
metadata_style(date, '-') || time.is_some_and(|t| metadata_style(t, ':'))
}
fn parse_duration_datetime_style(
date: &str,
time: Option<&str>,
tiers: &mut DurationTiers,
) -> Result<()> {
if !date.is_empty() {
parse_duration_date(date, &mut tiers.months, &mut tiers.days)?;
}
if let Some(t) = time {
let parts: Vec<&str> = t.split(':').collect();
const TIME_FIELDS: [i128; 3] = [NANOS_PER_HOUR, NANOS_PER_MINUTE, NANOS_PER_SECOND];
if parts.len() > TIME_FIELDS.len() {
return Err(Error::ty("invalid duration time"));
}
for (index, scale) in TIME_FIELDS.iter().enumerate() {
let Some(field) = parts.get(index) else {
break;
};
if field.is_empty() {
return Err(Error::ty("invalid duration time"));
}
let (whole, frac) =
split_duration_numeral(field).map_err(|_| Error::ty("invalid duration time"))?;
tiers.nanos.add_unit(whole, frac, *scale)?;
}
}
Ok(())
}
fn parse_duration_date(
date: &str,
months: &mut ExactAccumulator,
days: &mut ExactAccumulator,
) -> Result<()> {
let mut fields = date.split('-');
if let Some(year) = fields.next() {
months.add_whole(parse_duration_date_field(year)?, MONTHS_PER_YEAR)?;
}
if let Some(month) = fields.next() {
months.add_whole(parse_duration_date_field(month)?, 1)?;
}
if let Some(day) = fields.next() {
days.add_whole(parse_duration_date_field(day)?, 1)?;
}
if fields.next().is_some() {
return Err(Error::ty("invalid duration date"));
}
Ok(())
}
fn parse_duration_date_field(field: &str) -> Result<i128> {
field
.parse::<i128>()
.map_err(|_| Error::ty("invalid duration date"))
}