Add IANA/BCP47 time zone name mappings

components/timezone/src/provider.rs

@@ -21,6 +21,11 @@ use tinystr::TinyAsciiStr;
 use zerovec::ule::{AsULE, ULE};
 use zerovec::{ZeroMap2d, ZeroSlice, ZeroVec};
 
+pub mod names;
+
+pub use names::Bcp47ToIanaMapV1Marker;
+pub use names::IanaToBcp47MapV1Marker;
+
 /// TimeZone ID in BCP47 format
 ///
 /// <div class="stab unstable">

components/timezone/src/provider/names.rs

@@ -0,0 +1,207 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+//! 🚧 \[Unstable\] Property names-related data for this component
+//!
+//! <div class="stab unstable">
+//! 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+//! including in SemVer minor releases. While the serde representation of data structs is guaranteed
+//! to be stable, their Rust representation might not be. Use with caution.
+//! </div>
+//!
+//! Read more about data providers: [`icu_provider`]
+
+use alloc::boxed::Box;
+use core::cmp::Ordering;
+use core::str;
+
+use icu_provider::prelude::*;
+
+use crate::TimeZoneBcp47Id;
+use tinystr::UnvalidatedTinyAsciiStr;
+use zerovec::ule::{UnvalidatedStr, VarULE};
+use zerovec::{maps::ZeroMapKV, VarZeroSlice, VarZeroVec, ZeroMap};
+
+/// This is a time zone identifier that can be "loose matched" as according to
+/// [ECMAScript Temporal](https://tc39.es/proposal-temporal/#sec-isavailabletimezonename)
+///
+/// (matched case-insensitively in ASCII)
+///
+/// This is expected to be ASCII, but we do not rely on this invariant anywhere except during
+/// datagen.
+///
+/// The Ord impl will sort things using strict equality, but in such a way that all loose-equal items
+/// will sort into the same area, such that a map can be searched for both strict and loose equality.
+///
+/// <div class="stab unstable">
+/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
+/// to be stable, their Rust representation might not be. Use with caution.
+/// </div>
+///
+/// # Examples
+///
+/// Using a [`NormalizedTimeZoneIdStr`] as the key of a [`ZeroMap`]:
+///
+/// ```
+/// use icu_timezone::provider::names::NormalizedTimeZoneIdStr;
+/// use zerovec::ZeroMap;
+///
+/// let map: ZeroMap<NormalizedTimeZoneIdStr, usize> = [
+///     (NormalizedTimeZoneIdStr::from_str("America/Los_Angeles"), 11),
+///     (NormalizedTimeZoneIdStr::from_str("Asia/Kolkata"), 22),
+///     (NormalizedTimeZoneIdStr::from_str("Europe/Berlin"), 33),
+/// ]
+/// .into_iter()
+/// .collect();
+///
+/// let key_approx = NormalizedTimeZoneIdStr::from_str("europe/berlin");
+/// let key_exact = NormalizedTimeZoneIdStr::from_str("Europe/Berlin");
+///
+/// // Strict lookup:
+/// assert_eq!(None, map.get_copied(key_approx));
+/// assert_eq!(Some(33), map.get_copied(key_exact));
+///
+/// // Loose lookup:
+/// assert_eq!(Some(33), map.get_copied_by(|u| u.cmp_loose(key_approx)));
+/// assert_eq!(Some(33), map.get_copied_by(|u| u.cmp_loose(key_exact)));
+/// ```
+#[derive(PartialEq, Eq)] // VarULE wants these to be byte equality
+#[derive(Debug, VarULE)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[repr(transparent)]
+pub struct NormalizedTimeZoneIdStr(UnvalidatedStr);
+
+/// This impl requires enabling the optional `serde` Cargo feature of the `icu_properties` crate
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Box<NormalizedTimeZoneIdStr> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        <Box<UnvalidatedStr>>::deserialize(deserializer).map(NormalizedTimeZoneIdStr::cast_box)
+    }
+}
+
+/// This impl requires enabling the optional `serde` Cargo feature of the `icu_properties` crate
+#[cfg(feature = "serde")]
+impl<'de, 'a> serde::Deserialize<'de> for &'a NormalizedTimeZoneIdStr
+where
+    'de: 'a,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        <&UnvalidatedStr>::deserialize(deserializer).map(NormalizedTimeZoneIdStr::cast_ref)
+    }
+}
+
+impl<'a> ZeroMapKV<'a> for NormalizedTimeZoneIdStr {
+    type Container = VarZeroVec<'a, NormalizedTimeZoneIdStr>;
+    type Slice = VarZeroSlice<NormalizedTimeZoneIdStr>;
+    type GetType = NormalizedTimeZoneIdStr;
+    type OwnedType = Box<NormalizedTimeZoneIdStr>;
+}
+
+/// The Ord/PartialOrd impl will sort things using strict equality, but in such a way that all loose-equal items
+/// will sort into the same area, such that a map can be searched for both strict and loose equality.
+impl PartialOrd for NormalizedTimeZoneIdStr {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+/// The Ord impl will sort things using strict equality, but in such a way that all loose-equal items
+/// will sort into the same area, such that a map can be searched for both strict and loose equality.
+impl Ord for NormalizedTimeZoneIdStr {
+    fn cmp(&self, other: &Self) -> Ordering {
+        let cmp = self.cmp_loose(other);
+        // When loose equality holds, fall back to strict equality
+        if cmp == Ordering::Equal {
+            self.0.cmp(&other.0)
+        } else {
+            cmp
+        }
+    }
+}
+
+impl NormalizedTimeZoneIdStr {
+    /// Perform the loose comparison as defined in [`NormalizedTimeZoneIdStr`].
+    pub fn cmp_loose(&self, other: &Self) -> Ordering {
+        let self_iter = self.0.iter().map(u8::to_ascii_lowercase);
+        let other_iter = other.0.iter().map(u8::to_ascii_lowercase);
+        self_iter.cmp(other_iter)
+    }
+
+    /// Convert a string reference to a [`NormalizedTimeZoneIdStr`].
+    pub const fn from_str(s: &str) -> &Self {
+        Self::cast_ref(UnvalidatedStr::from_str(s))
+    }
+
+    /// Convert a [`UnvalidatedStr`] reference to a [`NormalizedTimeZoneIdStr`] reference.
+    pub const fn cast_ref(value: &UnvalidatedStr) -> &Self {
+        // Safety: repr(transparent)
+        unsafe { core::mem::transmute(value) }
+    }
+
+    /// Convert a [`UnvalidatedStr`] box to a [`NormalizedTimeZoneIdStr`] box.
+    pub const fn cast_box(value: Box<UnvalidatedStr>) -> Box<Self> {
+        // Safety: repr(transparent)
+        unsafe { core::mem::transmute(value) }
+    }
+
+    /// Get a [`NormalizedPropertyName`] box from a byte slice.
+    pub fn boxed_from_bytes(b: &[u8]) -> Box<Self> {
+        Self::cast_box(UnvalidatedStr::from_boxed_bytes(b.into()))
+    }
+}
+
+/// A mapping from IANA time zone identifiers to BCP-47 time zone identifiers.
+///
+/// Multiple IANA time zone IDs can map to the same BCP-47 time zone ID.
+///
+/// <div class="stab unstable">
+/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
+/// to be stable, their Rust representation might not be. Use with caution.
+/// </div>
+#[derive(Debug, Clone)]
+#[icu_provider::data_struct(marker(IanaToBcp47MapV1Marker, "time_zone/iana_to_bcp47@1"))]
+#[cfg_attr(
+    feature = "datagen", 
+    derive(serde::Serialize, databake::Bake),
+    databake(path = icu_timezone::provider::names),
+)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
+#[yoke(prove_covariance_manually)]
+pub struct IanaToBcp47MapV1<'data> {
+    /// A map from IANA time zone identifiers to BCP-47 time zone identifiers
+    #[cfg_attr(feature = "serde", serde(borrow))]
+    pub map: ZeroMap<'data, NormalizedTimeZoneIdStr, TimeZoneBcp47Id>,
+}
+
+/// A mapping from IANA time zone identifiers to BCP-47 time zone identifiers.
+///
+/// The BCP-47 time zone ID maps to the default IANA time zone ID according to the CLDR data.
+///
+/// <div class="stab unstable">
+/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
+/// to be stable, their Rust representation might not be. Use with caution.
+/// </div>
+#[derive(Debug, Clone)]
+#[icu_provider::data_struct(marker(Bcp47ToIanaMapV1Marker, "time_zone/bcp47_to_iana@1"))]
+#[cfg_attr(
+    feature = "datagen", 
+    derive(serde::Serialize, databake::Bake),
+    databake(path = icu_timezone::provider::names),
+)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
+#[yoke(prove_covariance_manually)]
+pub struct Bcp47ToIanaMapV1<'data> {
+    /// A map from BCP-47 time zone identifiers to IANA time zone identifiers
+    #[cfg_attr(feature = "serde", serde(borrow))]
+    pub map: ZeroMap<'data, UnvalidatedTinyAsciiStr<8>, str>,
+}

provider/datagen/src/registry.rs

@@ -110,6 +110,7 @@ registry!(
     AndListV1Marker,
     AsciiHexDigitV1Marker,
     BasicEmojiV1Marker,
+    Bcp47ToIanaMapV1Marker,
     BidiClassV1Marker,
     BidiClassNameToValueV1Marker,
     BidiClassValueToLongNameV1Marker,
@@ -193,6 +194,7 @@ registry!(
     GregorianDateSymbolsV1Marker,
     HexDigitV1Marker,
     HyphenV1Marker,
+    IanaToBcp47MapV1Marker,
     IdContinueV1Marker,
     IdeographicV1Marker,
     IdsBinaryOperatorV1Marker,

provider/datagen/src/transform/cldr/time_zones/convert.rs

@@ -18,6 +18,7 @@ use icu_datetime::provider::time_zones::{
 use icu_timezone::provider::MetazonePeriodV1;
 use icu_timezone::ZoneVariant;
 use std::borrow::Cow;
+use std::collections::BTreeMap;
 use std::collections::HashMap;
 use tinystr::TinyStr8;
 
@@ -41,10 +42,10 @@ fn parse_hour_format(hour_format: &str) -> (Cow<'static, str>, Cow<'static, str>
     (Cow::Owned(positive), Cow::Owned(negative))
 }
 
-fn compute_bcp47_tzids_hashmap(
+pub(crate) fn compute_bcp47_tzids_btreemap(
     bcp47_tzids_resource: &HashMap<TimeZoneBcp47Id, Bcp47TzidAliasData>,
-) -> HashMap<String, TimeZoneBcp47Id> {
-    let mut bcp47_tzids = HashMap::new();
+) -> BTreeMap<String, TimeZoneBcp47Id> {
+    let mut bcp47_tzids = BTreeMap::new();
     for (bcp47_tzid, bcp47_tzid_data) in bcp47_tzids_resource.iter() {
         if let Some(alias) = &bcp47_tzid_data.alias {
             for data_value in alias.split(' ') {
@@ -173,7 +174,7 @@ impl From<CldrTimeZonesData<'_>> for ExemplarCitiesV1<'static> {
 impl From<CldrTimeZonesData<'_>> for MetazonePeriodV1<'static> {
     fn from(other: CldrTimeZonesData<'_>) -> Self {
         let data = other.meta_zone_periods_resource;
-        let bcp47_tzid_data = &compute_bcp47_tzids_hashmap(other.bcp47_tzids_resource);
+        let bcp47_tzid_data = &compute_bcp47_tzids_btreemap(other.bcp47_tzids_resource);
         let meta_zone_id_data = &compute_meta_zone_ids_hashmap(other.meta_zone_ids_resource);
         Self(
             data.iter()
@@ -239,7 +240,7 @@ macro_rules! long_short_impls {
         impl From<CldrTimeZonesData<'_>> for $generic {
             fn from(other: CldrTimeZonesData<'_>) -> Self {
                 let data = other.time_zone_names_resource;
-                let bcp47_tzid_data = &compute_bcp47_tzids_hashmap(other.bcp47_tzids_resource);
+                let bcp47_tzid_data = &compute_bcp47_tzids_btreemap(other.bcp47_tzids_resource);
                 let meta_zone_id_data =
                     &compute_meta_zone_ids_hashmap(other.meta_zone_ids_resource);
                 Self {
@@ -326,7 +327,7 @@ macro_rules! long_short_impls {
         impl From<CldrTimeZonesData<'_>> for $specific {
             fn from(other: CldrTimeZonesData<'_>) -> Self {
                 let data = other.time_zone_names_resource;
-                let bcp47_tzid_data = &compute_bcp47_tzids_hashmap(other.bcp47_tzids_resource);
+                let bcp47_tzid_data = &compute_bcp47_tzids_btreemap(other.bcp47_tzids_resource);
                 let meta_zone_id_data =
                     &compute_meta_zone_ids_hashmap(other.meta_zone_ids_resource);
                 Self {

provider/datagen/src/transform/cldr/time_zones/mod.rs

@@ -15,6 +15,7 @@ use icu_timezone::provider::*;
 use std::collections::HashMap;
 
 mod convert;
+mod names;
 
 #[derive(Debug, Copy, Clone)]
 struct CldrTimeZonesData<'a> {

provider/datagen/src/transform/cldr/time_zones/names.rs

@@ -0,0 +1,65 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use super::convert::compute_bcp47_tzids_btreemap;
+use crate::transform::cldr::cldr_serde;
+use icu_provider::datagen::IterableDataProvider;
+use icu_provider::prelude::*;
+use icu_timezone::provider::names::*;
+
+impl DataProvider<IanaToBcp47MapV1Marker> for crate::DatagenProvider {
+    fn load(&self, _: DataRequest) -> Result<DataResponse<IanaToBcp47MapV1Marker>, DataError> {
+        let resource: &cldr_serde::time_zones::bcp47_tzid::Resource =
+            self.source
+                .cldr()?
+                .bcp47()
+                .read_and_parse("timezone.json")?;
+        let bcp47_tzid_data = &compute_bcp47_tzids_btreemap(&resource.keyword.u.time_zones.values);
+        let data_struct = IanaToBcp47MapV1 {
+            map: bcp47_tzid_data
+                .iter()
+                .map(|(k, v)| (NormalizedTimeZoneIdStr::boxed_from_bytes(k.as_bytes()), v))
+                .collect(),
+        };
+        Ok(DataResponse {
+            metadata: Default::default(),
+            payload: Some(DataPayload::from_owned(data_struct)),
+        })
+    }
+}
+
+impl IterableDataProvider<IanaToBcp47MapV1Marker> for crate::DatagenProvider {
+    fn supported_locales(&self) -> Result<Vec<DataLocale>, DataError> {
+        Ok(vec![Default::default()])
+    }
+}
+
+impl DataProvider<Bcp47ToIanaMapV1Marker> for crate::DatagenProvider {
+    fn load(&self, _: DataRequest) -> Result<DataResponse<Bcp47ToIanaMapV1Marker>, DataError> {
+        let resource: &cldr_serde::time_zones::bcp47_tzid::Resource =
+            self.source
+                .cldr()?
+                .bcp47()
+                .read_and_parse("timezone.json")?;
+        // Note: The BTreeMap retains the order of the aliases, which is important for establishing
+        // the canonical order of the IANA names.
+        let bcp47_tzid_data = &compute_bcp47_tzids_btreemap(&resource.keyword.u.time_zones.values);
+        let data_struct = Bcp47ToIanaMapV1 {
+            map: bcp47_tzid_data
+                .iter()
+                .map(|(k, v)| (v.0.to_unvalidated(), k.as_str()))
+                .collect(),
+        };
+        Ok(DataResponse {
+            metadata: Default::default(),
+            payload: Some(DataPayload::from_owned(data_struct)),
+        })
+    }
+}
+
+impl IterableDataProvider<Bcp47ToIanaMapV1Marker> for crate::DatagenProvider {
+    fn supported_locales(&self) -> Result<Vec<DataLocale>, DataError> {
+        Ok(vec![Default::default()])
+    }
+}