use std::collections::BTreeSet;
use crate::Result;
use super::exact::DurationTiers;
use super::field::{PatternSymbol, NANOS_PER_SECOND};
use super::pattern::{
invalid_value, mismatch, nanos_from_fraction, note_field, read_literal, read_number,
};
use super::{range_err, DurationField, Temporal};
#[derive(Debug, Clone)]
enum DurationToken {
Field(DurationField),
Fraction,
Literal(String),
}
fn tokenize_duration(pattern: &str) -> Result<Vec<DurationToken>> {
let chars: Vec<char> = pattern.chars().collect();
let mut tokens = Vec::new();
let mut literal = String::new();
let mut index = 0;
let mut escaped = false;
let flush = |literal: &mut String, tokens: &mut Vec<DurationToken>| {
if !literal.is_empty() {
tokens.push(DurationToken::Literal(std::mem::take(literal)));
}
};
while index < chars.len() {
let c = chars[index];
if escaped {
if c == '\'' {
if chars.get(index + 1) == Some(&'\'') {
literal.push('\'');
index += 2;
continue;
}
escaped = false;
index += 1;
continue;
}
literal.push(c);
index += 1;
continue;
}
if c == '\'' {
escaped = true;
index += 1;
continue;
}
if let Some(symbol) = DurationField::pattern_symbol(c) {
while chars.get(index) == Some(&c) {
index += 1;
}
flush(&mut literal, &mut tokens);
tokens.push(match symbol {
PatternSymbol::Field(field) => DurationToken::Field(field),
PatternSymbol::FractionDigits => DurationToken::Fraction,
});
continue;
}
literal.push(c);
index += 1;
}
if escaped {
return Err(invalid_value("pattern parsing failed"));
}
flush(&mut literal, &mut tokens);
reject_duplicate_duration_fields(&tokens)?;
Ok(tokens)
}
#[derive(PartialEq, Eq, PartialOrd, Ord)]
enum DuplicateSlot {
Field(DurationField),
Fraction,
}
fn reject_duplicate_duration_fields(tokens: &[DurationToken]) -> Result<()> {
let mut seen = BTreeSet::new();
for token in tokens {
let slot = match token {
DurationToken::Field(field) => DuplicateSlot::Field(*field),
DurationToken::Fraction => DuplicateSlot::Fraction,
DurationToken::Literal(_) => continue,
};
note_field(&mut seen, slot)?;
}
Ok(())
}
pub(super) fn parse_duration_pattern(value: &str, pattern: &str) -> Result<Temporal> {
let tokens = tokenize_duration(pattern)?;
let mut tiers = DurationTiers::default();
let mut pos = 0usize;
for token in &tokens {
match token {
DurationToken::Literal(text) => {
if read_literal(value, &mut pos, text).is_none() {
return Err(mismatch());
}
}
DurationToken::Field(field) => {
let number = match read_number(value, &mut pos, None, true)? {
Some(number) => number,
None => return Err(mismatch()),
};
let (accumulator, scale) = field.scaled(&mut tiers);
let check_unit = i64::try_from(if scale >= NANOS_PER_SECOND {
scale / NANOS_PER_SECOND
} else {
scale
})
.map_err(|_| range_err())?;
number.value.checked_mul(check_unit).ok_or_else(range_err)?;
accumulator.add_whole(i128::from(number.value), scale)?;
}
DurationToken::Fraction => {
let number = match read_number(value, &mut pos, None, false)? {
Some(number) => number,
None => return Err(mismatch()),
};
let nanos = nanos_from_fraction(number.value, number.digits)?;
tiers.nanos.add_whole(i128::from(nanos), 1)?;
}
}
}
if pos != value.len() {
return Err(mismatch());
}
let (months, days, nanos) = tiers.finish()?;
Temporal::duration_checked_exact(months, days, nanos)
}