Implement MeasureUnit

experimental/unitsconversion/src/lib.rs

@@ -6,4 +6,18 @@
 
 extern crate alloc;
 
+pub mod measureunit;
 pub mod provider;
+
+/// Represents the possible errors that can occur during the measurement unit operations.
+pub enum ConversionError {
+    /// The unit is not valid.
+    /// This can happen if the unit id is not following the CLDR specification.
+    /// For example, `meter` is a valid unit id, but `metre` is not.
+    InvalidUnit,
+
+    /// The conversion is not valid.
+    /// This can happen if the units are not compatible.
+    /// For example, `meter` and `foot` are compatible, but `meter` and `second` are not.
+    InvalidConversion,
+}

experimental/unitsconversion/src/measureunit.rs

@@ -0,0 +1,269 @@
+// 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 zerotrie::ZeroTrie;
+use zerovec::ZeroVec;
+
+use crate::{
+    provider::{Base, MeasureUnitItem, SiPrefix},
+    ConversionError,
+};
+
+// TODO(#4369): split this struct to two structs: MeasureUnitParser for parsing the identifier and MeasureUnit to represent the unit.
+#[zerovec::make_varule(MeasureUnitULE)]
+#[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq, Default)]
+#[cfg_attr(
+    feature = "datagen",
+    derive(databake::Bake),
+    databake(path = icu_unitsconversion::provider),
+)]
+#[cfg_attr(
+    feature = "datagen",
+    derive(serde::Serialize),
+    zerovec::derive(Serialize)
+)]
+#[cfg_attr(
+    feature = "serde",
+    derive(serde::Deserialize),
+    zerovec::derive(Deserialize)
+)]
+#[zerovec::derive(Debug)]
+pub struct MeasureUnit<'data> {
+    /// Contains the processed units.
+    #[cfg_attr(feature = "serde", serde(borrow))]
+    pub contained_units: ZeroVec<'data, MeasureUnitItem>,
+}
+
+impl MeasureUnit<'_> {
+    // TODO: consider returning Option<(u8, &str)> instead of (1, part) for the case when the power is not found.
+    // TODO: complete all the cases for the powers.
+    // TODO: consider using a trie for the powers.
+    /// Get the power of the unit.
+    /// NOTE:
+    ///    if the power is found, the function will return (power, part without the power).
+    ///    if the power is not found, the function will return (1, part).
+    fn get_power(part: &str) -> (u8, &str) {
+        if let Some(part) = part.strip_prefix("square-") {
+            (2, part)
+        } else if let Some(part) = part.strip_prefix("pow2-") {
+            (2, part)
+        } else if let Some(part) = part.strip_prefix("cubic-") {
+            (3, part)
+        } else if let Some(part) = part.strip_prefix("pow3-") {
+            (3, part)
+        } else if let Some(part) = part.strip_prefix("pow4-") {
+            (4, part)
+        } else if let Some(part) = part.strip_prefix("pow5-") {
+            (5, part)
+        } else if let Some(part) = part.strip_prefix("pow6-") {
+            (6, part)
+        } else if let Some(part) = part.strip_prefix("pow7-") {
+            (7, part)
+        } else if let Some(part) = part.strip_prefix("pow8-") {
+            (8, part)
+        } else if let Some(part) = part.strip_prefix("pow9-") {
+            (9, part)
+        } else {
+            (1, part)
+        }
+    }
+
+    // TODO: complete all the cases for the prefixes.
+    // TODO: consider using a trie for the prefixes.
+    /// Get the SI prefix.
+    /// NOTE:
+    ///    if the prefix is found, the function will return (power, base, part without the prefix).
+    ///    if the prefix is not found, the function will return (0, Base::NotExist, part).
+    fn get_si_prefix(part: &str) -> (SiPrefix, &str) {
+        let (si_prefix_base_10, part) = Self::get_si_prefix_base_10(part);
+        if si_prefix_base_10 != 0 {
+            return (
+                SiPrefix {
+                    power: si_prefix_base_10,
+                    base: Base::Decimal,
+                },
+                part,
+            );
+        }
+
+        let (si_prefix_base_2, part) = Self::get_si_prefix_base_two(part);
+        if si_prefix_base_2 != 0 {
+            return (
+                SiPrefix {
+                    power: si_prefix_base_2,
+                    base: Base::Binary,
+                },
+                part,
+            );
+        }
+
+        (
+            SiPrefix {
+                power: 0,
+                base: Base::Decimal,
+            },
+            part,
+        )
+    }
+
+    // TODO: consider returning Option<(i8, &str)> instead of (0, part) for the case when the prefix is not found.
+    // TODO: consider using a trie for the prefixes.
+    // TODO: complete all the cases for the prefixes.
+    /// Get the SI prefix for base 10.
+    /// NOTE:
+    ///    if the prefix is found, the function will return (power, part without the prefix).
+    ///   if the prefix is not found, the function will return (0, part).
+    fn get_si_prefix_base_10(part: &str) -> (i8, &str) {
+        if let Some(part) = part.strip_prefix("quetta") {
+            (30, part)
+        } else if let Some(part) = part.strip_prefix("ronna") {
+            (27, part)
+        } else if let Some(part) = part.strip_prefix("yotta") {
+            (24, part)
+        } else if let Some(part) = part.strip_prefix("zetta") {
+            (21, part)
+        } else if let Some(part) = part.strip_prefix("exa") {
+            (18, part)
+        } else if let Some(part) = part.strip_prefix("peta") {
+            (15, part)
+        } else if let Some(part) = part.strip_prefix("tera") {
+            (12, part)
+        } else if let Some(part) = part.strip_prefix("giga") {
+            (9, part)
+        } else if let Some(part) = part.strip_prefix("mega") {
+            (6, part)
+        } else if let Some(part) = part.strip_prefix("kilo") {
+            (3, part)
+        } else if let Some(part) = part.strip_prefix("hecto") {
+            (2, part)
+        } else if let Some(part) = part.strip_prefix("deca") {
+            (1, part)
+        } else if let Some(part) = part.strip_prefix("deci") {
+            (-1, part)
+        } else if let Some(part) = part.strip_prefix("centi") {
+            (-2, part)
+        } else if let Some(part) = part.strip_prefix("milli") {
+            (-3, part)
+        } else if let Some(part) = part.strip_prefix("micro") {
+            (-6, part)
+        } else if let Some(part) = part.strip_prefix("nano") {
+            (-9, part)
+        } else if let Some(part) = part.strip_prefix("pico") {
+            (-12, part)
+        } else if let Some(part) = part.strip_prefix("femto") {
+            (-15, part)
+        } else if let Some(part) = part.strip_prefix("atto") {
+            (-18, part)
+        } else if let Some(part) = part.strip_prefix("zepto") {
+            (-21, part)
+        } else if let Some(part) = part.strip_prefix("yocto") {
+            (-24, part)
+        } else if let Some(part) = part.strip_prefix("ronto") {
+            (-27, part)
+        } else if let Some(part) = part.strip_prefix("quecto") {
+            (-30, part)
+        } else {
+            (0, part)
+        }
+    }
+
+    // TODO: consider returning Option<(i8, &str)> instead of (0, part) for the case when the prefix is not found.
+    // TODO: consider using a trie for the prefixes.
+    // TODO: complete all the cases for the prefixes.
+    /// Get the SI prefix for base 2.
+    /// NOTE:
+    ///     if the prefix is found, the function will return (power, part without the prefix).
+    ///     if the prefix is not found, the function will return (0, part).
+    fn get_si_prefix_base_two(part: &str) -> (i8, &str) {
+        if let Some(part) = part.strip_prefix("kibi") {
+            (10, part)
+        } else if let Some(part) = part.strip_prefix("mebi") {
+            (20, part)
+        } else if let Some(part) = part.strip_prefix("gibi") {
+            (30, part)
+        } else if let Some(part) = part.strip_prefix("tebi") {
+            (40, part)
+        } else if let Some(part) = part.strip_prefix("pebi") {
+            (50, part)
+        } else if let Some(part) = part.strip_prefix("exbi") {
+            (60, part)
+        } else if let Some(part) = part.strip_prefix("zebi") {
+            (70, part)
+        } else if let Some(part) = part.strip_prefix("yobi") {
+            (80, part)
+        } else {
+            (0, part)
+        }
+    }
+
+    // TODO: consider using a sufficient trie search for finding the unit id.
+    /// Get the unit id.
+    /// NOTE:
+    ///    if the unit id is found, the function will return (unit id, part without the unit id and without `-` at the beginning of the remaining part if it exists).
+    ///    if the unit id is not found, the function will return None.
+    fn get_unit_id<'data>(
+        part: &'data str,
+        trie: &ZeroTrie<ZeroVec<'data, u8>>,
+    ) -> Option<(usize, &'data str)> {
+        // TODO(#4379): this is inefficient way to search for an item in a trie.
+        // we must implement a way to search for a prefix in a trie.
+        let mut result = None;
+        for (index, _) in part.char_indices() {
+            let identifier = &part[..=index];
+            if let Some(value) = trie.get(identifier.as_bytes()) {
+                result = Some((value, &part[identifier.len()..]));
+            }
+        }
+
+        result
+    }
+
+    /// Process a part of an identifier.
+    /// For example, if the whole identifier is: "square-kilometer-per-second",
+    /// this function will be called for "square-kilometer" with sign (1) and "second" with sign (-1).
+    fn analyze_identifier_part(
+        identifier_part: &str,
+        sign: i8,
+        result: &mut Vec<MeasureUnitItem>,
+        trie: &ZeroTrie<ZeroVec<'_, u8>>,
+    ) -> Result<(), ConversionError> {
+        let mut identifier = identifier_part;
+        while !identifier.is_empty() {
+            let (power, identifier_after_power) = Self::get_power(identifier);
+            let (si_prefix, identifier_after_si) = Self::get_si_prefix(identifier_after_power);
+            let (unit_id, identifier_after_unit) =
+                match Self::get_unit_id(identifier_after_si, trie) {
+                    Some((unit_id, identifier_after_unit)) => (unit_id, identifier_after_unit),
+                    None => return Err(ConversionError::InvalidUnit),
+                };
+
+            result.push(MeasureUnitItem {
+                power: power as i8 * sign,
+                si_prefix,
+                unit_id: unit_id as u16,
+            });
+
+            identifier = identifier_after_unit.get(1..).unwrap_or("");
+        }
+
+        Ok(())
+    }
+
+    // TODO: add test cases for this function.
+    /// Process an identifier.
+    pub fn try_from_identifier<'data>(
+        identifier: &'data str,
+        trie: &ZeroTrie<ZeroVec<'data, u8>>,
+    ) -> Result<Vec<MeasureUnitItem>, ConversionError> {
+        let (num_part, den_part) = identifier
+            .split_once("-per-")
+            .or_else(|| identifier.split_once("per-"))
+            .unwrap_or((identifier, ""));
+
+        let mut measure_unit_items = Vec::<MeasureUnitItem>::new();
+        Self::analyze_identifier_part(num_part, 1, &mut measure_unit_items, trie)?;
+        Self::analyze_identifier_part(den_part, -1, &mut measure_unit_items, trie)?;
+        Ok(measure_unit_items)
+    }
+}

experimental/unitsconversion/src/provider.rs

@@ -9,7 +9,6 @@
 //!
 //! Read more about data providers: [`icu_provider`]
 
-use alloc::borrow::Cow;
 use icu_provider::prelude::*;
 use zerotrie::ZeroTrie;
 use zerovec::{VarZeroVec, ZeroVec};
@@ -37,7 +36,7 @@ pub const KEYS: &[DataKey] = &[UnitsInfoV1Marker::KEY];
 pub struct UnitsInfoV1<'data> {
     /// Maps from unit name (e.g. foot) to it is conversion information.
     #[cfg_attr(feature = "serde", serde(borrow))]
-    pub units_conversion_map: ZeroTrie<ZeroVec<'data, u8>>,
+    pub units_conversion_trie: ZeroTrie<ZeroVec<'data, u8>>,
 
     /// Contains the conversion information, such as the conversion rate and the base unit.
     /// For example, the conversion information for the unit `foot` is `1 foot = 0.3048 meter`.
@@ -66,9 +65,9 @@ pub struct UnitsInfoV1<'data> {
 )]
 #[zerovec::derive(Debug)]
 pub struct ConversionInfo<'data> {
-    /// Contains the base unit which the unit is converted to.
+    /// Contains the base unit (after parsing) which what the unit is converted to.
     #[cfg_attr(feature = "serde", serde(borrow))]
-    pub base_unit: Cow<'data, str>,
+    pub basic_units: ZeroVec<'data, MeasureUnitItem>,
 
     /// Represents the numerator of the conversion factor.
     #[cfg_attr(feature = "serde", serde(borrow))]
@@ -129,3 +128,62 @@ pub enum Exactness {
     Exact = 0,
     Approximate = 1,
 }
+
+#[zerovec::make_ule(BaseULE)]
+#[cfg_attr(
+    feature = "datagen",
+    derive(serde::Serialize, databake::Bake),
+    databake(path = icu_unitsconversion::provider),
+)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
+#[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq, Default)]
+#[repr(u8)]
+pub enum Base {
+    /// The base of the si prefix is 10.
+    #[default]
+    Decimal = 0,
+
+    /// The base of the si prefix is 2.
+    Binary = 1,
+}
+
+/// Represents an Item of a MeasureUnit.
+/// For example, the MeasureUnit `kilometer-per-square-second` contains two items:
+///    1. `kilometer` with power 1 and prefix 3 with base 10.
+///    2. `second` with power -2 and prefix `NotExist`.
+#[zerovec::make_ule(MeasureUnitItemULE)]
+#[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq, Default)]
+#[cfg_attr(
+    feature = "datagen",
+    derive(serde::Serialize, databake::Bake),
+    databake(path = icu_unitsconversion::provider),
+)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
+pub struct MeasureUnitItem {
+    /// The power of the unit.
+    pub power: i8,
+
+    /// The si base of the unit.
+    pub si_prefix: SiPrefix,
+
+    /// The id of the unit.
+    pub unit_id: u16,
+}
+
+// TODO: Consider reducing the size of this struct while implementing the ULE.
+/// Represents the SI prefix.
+#[zerovec::make_ule(SiPrefixULE)]
+#[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq, Default)]
+#[cfg_attr(
+    feature = "datagen",
+    derive(serde::Serialize, databake::Bake),
+    databake(path = icu_unitsconversion::provider),
+)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
+pub struct SiPrefix {
+    /// The absolute value of the power of the si prefix.
+    pub power: i8,
+
+    /// The base of the si prefix.
+    pub base: Base,
+}