Checkpoint

Author: sffc

components/datetime/src/provider/neo/packed_pattern.rs

@@ -21,8 +21,6 @@ pub struct PackedSkeletonDataBuilder<'a> {
     pub variant1: Option<LengthPluralElements<'a>>,
 }
 
-
-
 // #[zerovec::make_varule(TaggedPatternULE)]
 pub struct TaggedPattern<'data> {
     pub tag: u8,

components/plurals/src/provider.rs

@@ -15,9 +15,17 @@
 //!
 //! Read more about data providers: [`icu_provider`]
 
-use crate::rules::runtime::ast::Rule;
+use core::marker::PhantomData;
 use icu_provider::prelude::*;
 use icu_provider::DynamicDataMarker;
+use zerovec::ule::vartuple::TinyVarVar;
+use zerovec::ule::vartuple::TinyVarVarULE;
+use zerovec::ule::vartuple::VarTupleULE;
+use zerovec::ule::UleError;
+use zerovec::ule::VarULE;
+use zerovec::ule::ULE;
+use zerovec::VarZeroSlice;
+use crate::rules::runtime::ast::Rule;
 
 #[cfg(feature = "compiled_data")]
 #[derive(Debug)]
@@ -327,7 +335,7 @@ use alloc::borrow::Cow;
 use zerovec::ule::AsULE;
 use zerovec::VarZeroVec;
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[zerovec::make_ule(PluralCategoryV1ULE)]
 #[repr(u8)]
 #[cfg_attr(feature = "datagen", derive(serde::Serialize))]
@@ -475,12 +483,190 @@ impl<'a, 'b> From<PluralElements<'b, str>> for PluralElementsV1<'a> {
     }
 }
 
-struct PluralElementsSingletonVarULE<V> {}
-
-struct PluralElementsMapVarULE {}
-
 #[test]
 fn plural_elements_niche() {
     assert_eq!(core::mem::size_of::<PluralElementsV1>(), 48);
     assert_eq!(core::mem::size_of::<Option<PluralElementsV1>>(), 48);
 }
+
+/// Four bits of metadata that are stored and retrieved with the plural elements.
+#[derive(Debug, Copy, Clone)]
+#[repr(transparent)]
+pub struct FourBitMetadata(u8);
+
+/// Representation: `ppppmmmm`
+/// - `pppp` = plural category (including explicit value)
+/// - `mmmm` = [`FourBitMetadata`]
+#[derive(Debug, Copy, Clone)]
+#[repr(transparent)]
+struct PluralCategoryAndMetadata(
+    // Invariant: representation is as stated in the struct docs
+    u8,
+);
+
+impl PluralCategoryAndMetadata {
+    fn get(self) -> (PluralElementsKeysV1, FourBitMetadata) {
+        let plural_category_byte = (self.0 & 0xF0) >> 4;
+        // Safety: by invariant
+        let plural_category =
+            unsafe { PluralElementsKeysV1::new_from_u8(plural_category_byte).unwrap_unchecked() };
+        let metadata = FourBitMetadata(self.0 & 0x0F);
+        (plural_category, metadata)
+    }
+}
+
+unsafe impl ULE for PluralCategoryAndMetadata {
+    fn validate_byte_slice(bytes: &[u8]) -> Result<(), zerovec::ule::UleError> {
+        bytes
+            .iter()
+            .all(|byte| {
+                let plural_category_byte = (byte & 0xF0) >> 4;
+                PluralElementsKeysV1::new_from_u8(plural_category_byte).is_some()
+            })
+            .then_some(())
+            .ok_or_else(|| UleError::parse::<Self>())
+    }
+}
+
+impl AsULE for PluralCategoryAndMetadata {
+    type ULE = Self;
+    #[inline]
+    fn to_unaligned(self) -> Self::ULE {
+        self
+    }
+    #[inline]
+    fn from_unaligned(unaligned: Self::ULE) -> Self {
+        unaligned
+    }
+}
+
+type PluralElementsSingletonVarULE<V> = V;
+
+type PluralElementsTupleSliceVarULE<V> = VarZeroSlice<VarTupleULE<PluralCategoryAndMetadata, V>>;
+
+type PluralElementsDefaultMapVarULE<V> = TinyVarVarULE<V, PluralElementsTupleSliceVarULE<V>>;
+
+fn get_special<V: VarULE + ?Sized>(
+    data: &PluralElementsTupleSliceVarULE<V>,
+    key: PluralElementsKeysV1,
+) -> Option<(&V, FourBitMetadata)> {
+    data.iter()
+        .filter_map(|ule| {
+            let (current_key, metadata) = ule.sized.get();
+            (current_key == key).then_some((&ule.variable, metadata))
+        })
+        .next()
+}
+
+/// A bitpacked DST for [`PluralElements`].
+///
+/// Can be put in a [`Cow`] or a [`VarZeroVec`].
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct PluralElementsPackedULE<V: VarULE + ?Sized> {
+    _v: PhantomData<V>,
+    /// Invariant Representation:
+    ///
+    /// First byte: `d...mmmm`
+    /// - `d` = 0 if singleton, 1 if a map
+    /// - `...` = padding, should be 0
+    /// - `mmmm` = [`FourBitMetadata`] for the default value
+    ///
+    /// Remainder: either [`PluralElementsSingletonVarULE`] or [`PluralElementsDefaultMapVarULE`]
+    /// based on the discriminant `d`
+    bytes: [u8],
+}
+
+impl<V: VarULE + ?Sized> ToOwned for PluralElementsPackedULE<V> {
+    type Owned = Box<PluralElementsPackedULE<V>>;
+    fn to_owned(&self) -> Self::Owned {
+        self.to_boxed()
+    }
+}
+
+unsafe impl<V> VarULE for PluralElementsPackedULE<V>
+where
+    V: VarULE + ?Sized,
+{
+    fn validate_byte_slice(bytes: &[u8]) -> Result<(), zerovec::ule::UleError> {
+        let (lead_byte, remainder) = bytes
+            .split_first()
+            .ok_or_else(|| UleError::length::<Self>(bytes.len()))?;
+        if lead_byte & 0x8F != 0 {
+            return Err(UleError::parse::<Self>());
+        }
+        if lead_byte & 0x80 == 0 {
+            PluralElementsSingletonVarULE::<V>::validate_byte_slice(remainder)
+        } else {
+            PluralElementsDefaultMapVarULE::<V>::validate_byte_slice(remainder)
+        }
+    }
+
+    unsafe fn from_byte_slice_unchecked(bytes: &[u8]) -> &Self {
+        // Safety: the bytes are valid by trait invariant, and we are transparent over bytes
+        core::mem::transmute(bytes)
+    }
+}
+
+impl<V> PluralElementsPackedULE<V>
+where
+    V: VarULE + ?Sized,
+{
+    /// Unpacks this structure into the default value and the optional list of specials.
+    fn as_parts(
+        &self,
+    ) -> (
+        (&V, FourBitMetadata),
+        Option<&PluralElementsTupleSliceVarULE<V>>,
+    ) {
+        // Safety: the bytes are valid by invariant
+        let (lead_byte, remainder) = unsafe { self.bytes.split_first().unwrap_unchecked() };
+        let metadata = FourBitMetadata(lead_byte & 0x0F);
+        if lead_byte & 0x80 == 0 {
+            // Safety: the bytes are valid by invariant
+            let inner =
+                unsafe { PluralElementsSingletonVarULE::<V>::from_byte_slice_unchecked(remainder) };
+            ((inner, metadata), None)
+        } else {
+            // Safety: the bytes are valid by invariant
+            let inner = unsafe {
+                PluralElementsDefaultMapVarULE::<V>::from_byte_slice_unchecked(remainder)
+            };
+            let (default, tuple_slice) = inner.get();
+            ((default, metadata), Some(tuple_slice))
+        }
+    }
+
+    /// Returns the value for the given [`PluralOperands`] and [`PluralRules`].
+    pub fn get<'a>(&'a self, op: PluralOperands, rules: &PluralRules) -> (&'a V, FourBitMetadata) {
+        let (default, specials) = self.as_parts();
+
+        let category = rules.category_for(op);
+
+        match specials {
+            Some(specials) => {
+                if op.is_exactly_zero() {
+                    if let Some(value) = get_special(specials, PluralElementsKeysV1::ExplicitZero) {
+                        return value;
+                    }
+                }
+                if op.is_exactly_one() {
+                    if let Some(value) = get_special(specials, PluralElementsKeysV1::ExplicitOne) {
+                        return value;
+                    }
+                }
+                match category {
+                    PluralCategory::Zero => Some(PluralElementsKeysV1::Zero),
+                    PluralCategory::One => Some(PluralElementsKeysV1::One),
+                    PluralCategory::Two => Some(PluralElementsKeysV1::Two),
+                    PluralCategory::Few => Some(PluralElementsKeysV1::Few),
+                    PluralCategory::Many => Some(PluralElementsKeysV1::Many),
+                    PluralCategory::Other => None,
+                }
+                .and_then(|key| get_special(specials, key))
+            }
+            None => None,
+        }
+        .unwrap_or(default)
+    }
+}