use crate::{
Error, Instant, NamedTimeZoneIdentifier, TimeZone, TransitionDirection, TransitionZone,
named_time_zone_identifier,
};
#[derive(Clone, Copy, Debug)]
pub struct TimeZoneRecord<'a> {
identifier: &'static str,
provider: TransitionZone<'a>,
}
impl<'a> TimeZoneRecord<'a> {
pub fn new(identifier: &str, provider: TransitionZone<'a>) -> Result<Self, Error> {
let identity = named_time_zone_identifier(identifier).ok_or(Error::InvalidTimeZoneData)?;
if identity.identifier != identity.primary || identity.primary == "UTC" {
return Err(Error::InvalidTimeZoneData);
}
Ok(Self {
identifier: identity.primary,
provider,
})
}
pub const fn identifier(&self) -> &'static str {
self.identifier
}
}
#[derive(Clone, Copy, Debug)]
pub struct TimeZoneRegistry<'a> {
records: &'a [TimeZoneRecord<'a>],
}
impl<'a> TimeZoneRegistry<'a> {
pub const fn empty() -> Self {
Self { records: &[] }
}
pub fn new(records: &'a [TimeZoneRecord<'a>]) -> Result<Self, Error> {
if records
.windows(2)
.any(|pair| pair[0].identifier >= pair[1].identifier)
{
return Err(Error::InvalidTimeZoneData);
}
Ok(Self { records })
}
pub const fn records(&self) -> &'a [TimeZoneRecord<'a>] {
self.records
}
pub fn resolve(&self, identifier: &str) -> Result<ResolvedTimeZone<'a>, Error> {
if identifier.starts_with(['+', '-']) {
let (seconds, name) = offset_identifier(identifier)?;
return Ok(ResolvedTimeZone {
identity: Identity::Offset(name),
provider: TransitionZone::new(seconds, &[], None)?,
});
}
let identity = named_time_zone_identifier(identifier).ok_or(Error::InvalidTimeZone)?;
let provider = if identity.primary == "UTC" {
TransitionZone::new(0, &[], None)?
} else {
let index = self
.records
.binary_search_by_key(&identity.primary, |record| record.identifier)
.map_err(|_| Error::MissingTimeZoneData)?;
self.records[index].provider
};
Ok(ResolvedTimeZone {
identity: Identity::Named(identity),
provider,
})
}
}
impl TimeZoneRegistry<'static> {
#[cfg(feature = "compiled_time_zones")]
pub const fn compiled() -> Self {
Self {
records: compiled::ZONES,
}
}
}
impl Default for TimeZoneRegistry<'_> {
fn default() -> Self {
Self::empty()
}
}
#[derive(Clone, Copy, Debug)]
enum Identity {
Named(NamedTimeZoneIdentifier),
Offset([u8; 6]),
}
#[derive(Clone, Copy, Debug)]
pub struct ResolvedTimeZone<'a> {
identity: Identity,
provider: TransitionZone<'a>,
}
impl<'a> ResolvedTimeZone<'a> {
pub fn identifier(&self) -> &str {
match &self.identity {
Identity::Named(identity) => identity.identifier,
Identity::Offset(name) => core::str::from_utf8(name).unwrap(),
}
}
pub fn primary_identifier(&self) -> &str {
match &self.identity {
Identity::Named(identity) => identity.primary,
Identity::Offset(_) => self.identifier(),
}
}
pub const fn provider(&self) -> TransitionZone<'a> {
self.provider
}
}
impl PartialEq for ResolvedTimeZone<'_> {
fn eq(&self, other: &Self) -> bool {
self.primary_identifier() == other.primary_identifier()
}
}
impl Eq for ResolvedTimeZone<'_> {}
impl core::fmt::Display for ResolvedTimeZone<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str(self.identifier())
}
}
impl TimeZone for ResolvedTimeZone<'_> {
fn offset_nanoseconds(&self, instant: Instant) -> i128 {
self.provider.offset_nanoseconds(instant)
}
fn visit_offsets(&self, visitor: &mut dyn FnMut(i128)) {
self.provider.visit_offsets(visitor);
}
fn transition(&self, instant: Instant, direction: TransitionDirection) -> Option<Instant> {
self.provider.transition(instant, direction)
}
}
fn offset_identifier(value: &str) -> Result<(i32, [u8; 6]), Error> {
let bytes = value.as_bytes();
let (hours, minutes) = match bytes {
[b'+' | b'-', a, b] => ([*a, *b], [b'0', b'0']),
[b'+' | b'-', a, b, c, d] | [b'+' | b'-', a, b, b':', c, d] => ([*a, *b], [*c, *d]),
_ => return Err(Error::InvalidTimeZone),
};
if !hours.iter().chain(minutes.iter()).all(u8::is_ascii_digit) {
return Err(Error::InvalidTimeZone);
}
let hour = (hours[0] - b'0') * 10 + hours[1] - b'0';
let minute = (minutes[0] - b'0') * 10 + minutes[1] - b'0';
if hour > 23 || minute > 59 {
return Err(Error::InvalidTimeZone);
}
let mut seconds = i32::from(hour) * 3600 + i32::from(minute) * 60;
if bytes[0] == b'-' {
seconds = -seconds;
}
Ok((
seconds,
[
if seconds < 0 { b'-' } else { b'+' },
hours[0],
hours[1],
b':',
minutes[0],
minutes[1],
],
))
}
#[cfg(feature = "compiled_time_zones")]
const fn checked_future(
standard: i32,
daylight: Option<(i32, crate::TransitionRule, crate::TransitionRule)>,
) -> crate::FutureRule {
match crate::FutureRule::new(standard, daylight) {
Ok(value) => value,
Err(_) => panic!("Invalid generated future rule"),
}
}
#[cfg(feature = "compiled_time_zones")]
const fn checked_zone(
initial: i32,
events: &'static [crate::OffsetTransition],
future: Option<crate::FutureRule>,
) -> TransitionZone<'static> {
match TransitionZone::new(initial, events, future) {
Ok(value) => value,
Err(_) => panic!("Invalid generated time zone"),
}
}
#[cfg(feature = "compiled_time_zones")]
mod compiled {
use super::{TimeZoneRecord, checked_future, checked_zone};
use crate::{OffsetTransition, TransitionRule};
include!(env!("FORMATJS_TEMPORAL_TIME_ZONES"));
}