use super::exact;
pub(super) const MONTHS_PER_YEAR: i128 = 12;
pub(super) const MONTHS_PER_QUARTER: i128 = 3;
pub(super) const DAYS_PER_WEEK: i128 = 7;
pub(super) const NANOS_PER_DAY: i128 = 24 * NANOS_PER_HOUR;
pub(super) const NANOS_PER_HOUR: i128 = 3_600_000_000_000;
pub(super) const NANOS_PER_MINUTE: i128 = 60_000_000_000;
pub(super) const NANOS_PER_SECOND: i128 = 1_000_000_000;
pub(super) const NANOS_PER_MILLI: i128 = 1_000_000;
pub(super) const NANOS_PER_MICRO: i128 = 1_000;
pub(super) const SECONDS_PER_MINUTE: i128 = NANOS_PER_MINUTE / NANOS_PER_SECOND;
pub(super) const SECONDS_PER_HOUR: i128 = NANOS_PER_HOUR / NANOS_PER_SECOND;
pub(super) const AVG_NANOS_PER_MONTH: f64 = AVG_SECONDS_PER_MONTH as f64 * NANOS_PER_SECOND as f64;
pub(super) const AVG_SECONDS_PER_MONTH: i128 = 2_629_746;
pub(super) const MAX_DURATION_SECONDS: i128 = 1 << 63;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub(super) enum DurationField {
Years,
Quarters,
Months,
Weeks,
Days,
Hours,
Minutes,
Seconds,
Millis,
Micros,
Nanos,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) enum DurationTier {
Months,
Days,
Nanos,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) enum PatternSymbol {
Field(DurationField),
FractionDigits,
}
impl PatternSymbol {
pub(super) fn field(self) -> DurationField {
match self {
Self::Field(field) => field,
Self::FractionDigits => DurationField::Nanos,
}
}
}
impl DurationField {
pub(super) const CASCADE: [Self; 11] = [
Self::Years,
Self::Quarters,
Self::Months,
Self::Weeks,
Self::Days,
Self::Hours,
Self::Minutes,
Self::Seconds,
Self::Millis,
Self::Micros,
Self::Nanos,
];
pub(super) fn name(self) -> &'static str {
match self {
Self::Years => "years",
Self::Quarters => "quarters",
Self::Months => "months",
Self::Weeks => "weeks",
Self::Days => "days",
Self::Hours => "hours",
Self::Minutes => "minutes",
Self::Seconds => "seconds",
Self::Millis => "milliseconds",
Self::Micros => "microseconds",
Self::Nanos => "nanoseconds",
}
}
pub(super) fn tier_and_scale(self) -> (DurationTier, i128) {
match self {
Self::Years => (DurationTier::Months, MONTHS_PER_YEAR),
Self::Quarters => (DurationTier::Months, MONTHS_PER_QUARTER),
Self::Months => (DurationTier::Months, 1),
Self::Weeks => (DurationTier::Days, DAYS_PER_WEEK),
Self::Days => (DurationTier::Days, 1),
Self::Hours => (DurationTier::Nanos, NANOS_PER_HOUR),
Self::Minutes => (DurationTier::Nanos, NANOS_PER_MINUTE),
Self::Seconds => (DurationTier::Nanos, NANOS_PER_SECOND),
Self::Millis => (DurationTier::Nanos, NANOS_PER_MILLI),
Self::Micros => (DurationTier::Nanos, NANOS_PER_MICRO),
Self::Nanos => (DurationTier::Nanos, 1),
}
}
pub(super) fn scaled(
self,
tiers: &mut exact::DurationTiers,
) -> (&mut exact::ExactAccumulator, i128) {
let (tier, scale) = self.tier_and_scale();
let accumulator = match tier {
DurationTier::Months => &mut tiers.months,
DurationTier::Days => &mut tiers.days,
DurationTier::Nanos => &mut tiers.nanos,
};
(accumulator, scale)
}
pub(super) fn pattern_symbol(c: char) -> Option<PatternSymbol> {
Some(match c {
'y' | 'Y' | 'u' => PatternSymbol::Field(Self::Years),
'q' | 'Q' => PatternSymbol::Field(Self::Quarters),
'M' | 'L' => PatternSymbol::Field(Self::Months),
'w' | 'W' => PatternSymbol::Field(Self::Weeks),
'd' | 'D' => PatternSymbol::Field(Self::Days),
'h' | 'H' | 'k' | 'K' => PatternSymbol::Field(Self::Hours),
'm' => PatternSymbol::Field(Self::Minutes),
's' => PatternSymbol::Field(Self::Seconds),
'A' => PatternSymbol::Field(Self::Millis),
'n' | 'S' => PatternSymbol::FractionDigits,
'N' => PatternSymbol::Field(Self::Nanos),
_ => return None,
})
}
pub(super) fn from_map_key(key: &str) -> Option<Self> {
Self::CASCADE.into_iter().find(|field| field.name() == key)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn average_month_nanos_matches_the_second_factor() {
assert_eq!(AVG_SECONDS_PER_MONTH, 3_652_425 * 86_400 / (10_000 * 12));
assert_eq!(AVG_NANOS_PER_MONTH, 2.629_746e15);
}
#[test]
fn map_keys_name_every_field_once() {
let keys = [
"years",
"quarters",
"months",
"weeks",
"days",
"hours",
"minutes",
"seconds",
"milliseconds",
"microseconds",
"nanoseconds",
];
let resolved: Vec<DurationField> = keys
.iter()
.map(|key| DurationField::from_map_key(key).expect("a duration map key"))
.collect();
assert_eq!(
resolved,
vec![
DurationField::Years,
DurationField::Quarters,
DurationField::Months,
DurationField::Weeks,
DurationField::Days,
DurationField::Hours,
DurationField::Minutes,
DurationField::Seconds,
DurationField::Millis,
DurationField::Micros,
DurationField::Nanos,
]
);
assert_eq!(DurationField::from_map_key("fortnights"), None);
}
#[test]
fn cascade_orders_every_tier_and_names_round_trip() {
for field in DurationField::CASCADE {
assert_eq!(DurationField::from_map_key(field.name()), Some(field));
}
let mut tiers: Vec<DurationTier> = DurationField::CASCADE
.iter()
.map(|field| field.tier_and_scale().0)
.collect();
tiers.dedup();
assert_eq!(
tiers,
vec![
DurationTier::Months,
DurationTier::Days,
DurationTier::Nanos
],
"the cascade keeps each tier contiguous"
);
}
}