Add total_cmp helper functions to icu_locid types and DataLocale (#…

…4608)

CHANGELOG.md

@@ -9,6 +9,8 @@
  - New `DateTime::local_unix_epoch()` convenience constructor (https://github.com/unicode-org/icu4x/pull/4479)
  - `icu_datetime`
  - `FormattedDateTime` and `FormattedZonedDateTime` now implement `Clone` and `Copy` (https://github.com/unicode-org/icu4x/pull/4476)
+ - `icu_locid`
+ - Added `total_cmp` functions to `Locale` and other types to make them easier to use in `BTreeSet` (https://github.com/unicode-org/icu4x/pull/4608)
  - `icu_properties`
  - Add `Aran` script code (https://github.com/unicode-org/icu4x/pull/4426)
  - Mark additional constructors as `const` (https://github.com/unicode-org/icu4x/pull/4584, https://github.com/unicode-org/icu4x/pull/4574)

components/locid/src/extensions/mod.rs

@@ -49,6 +49,8 @@ pub mod private;
 pub mod transform;
 pub mod unicode;
 
+use core::cmp::Ordering;
+
 use other::Other;
 use private::Private;
 use transform::Transform;
@@ -58,6 +60,7 @@ use alloc::vec::Vec;
 
 use crate::parser::ParserError;
 use crate::parser::SubtagIterator;
+use crate::subtags;
 
 /// Defines the type of extension.
 #[derive(Debug, PartialEq, Eq, Clone, Hash, PartialOrd, Ord, Copy)]
@@ -164,6 +167,41 @@ impl Extensions {
  && self.other.is_empty()
  }
 
+ #[allow(clippy::type_complexity)]
+ pub(crate) fn as_tuple(
+ &self,
+ ) -> (
+ (&unicode::Attributes, &unicode::Keywords),
+ (
+ Option<(
+ subtags::Language,
+ Option<subtags::Script>,
+ Option<subtags::Region>,
+ &subtags::Variants,
+ )>,
+ &transform::Fields,
+ ),
+ &private::Private,
+ &[other::Other],
+ ) {
+ (
+ self.unicode.as_tuple(),
+ self.transform.as_tuple(),
+ &self.private,
+ &self.other,
+ )
+ }
+
+ /// Returns an ordering suitable for use in [`BTreeSet`].
+ ///
+ /// The ordering may or may not be equivalent to string ordering, and it
+ /// may or may not be stable across ICU4X releases.
+ ///
+ /// [`BTreeSet`]: alloc::collections::BTreeSet
+ pub fn total_cmp(&self, other: &Self) -> Ordering {
+ self.as_tuple().cmp(&other.as_tuple())
+ }
+
  /// Retains the specified extension types, clearing all others.
  ///
  /// # Examples

components/locid/src/extensions/transform/mod.rs

@@ -34,6 +34,8 @@ mod fields;
 mod key;
 mod value;
 
+use core::cmp::Ordering;
+
 pub use fields::Fields;
 #[doc(inline)]
 pub use key::{key, Key};
@@ -42,7 +44,7 @@ pub use value::Value;
 use crate::parser::SubtagIterator;
 use crate::parser::{parse_language_identifier_from_iter, ParserError, ParserMode};
 use crate::shortvec::ShortBoxSlice;
-use crate::subtags::Language;
+use crate::subtags::{self, Language};
 use crate::LanguageIdentifier;
 use litemap::LiteMap;
 
@@ -131,6 +133,31 @@ impl Transform {
  self.fields.clear();
  }
 
+ #[allow(clippy::type_complexity)]
+ pub(crate) fn as_tuple(
+ &self,
+ ) -> (
+ Option<(
+ subtags::Language,
+ Option<subtags::Script>,
+ Option<subtags::Region>,
+ &subtags::Variants,
+ )>,
+ &Fields,
+ ) {
+ (self.lang.as_ref().map(|l| l.as_tuple()), &self.fields)
+ }
+
+ /// Returns an ordering suitable for use in [`BTreeSet`].
+ ///
+ /// The ordering may or may not be equivalent to string ordering, and it
+ /// may or may not be stable across ICU4X releases.
+ ///
+ /// [`BTreeSet`]: alloc::collections::BTreeSet
+ pub fn total_cmp(&self, other: &Self) -> Ordering {
+ self.as_tuple().cmp(&other.as_tuple())
+ }
+
  pub(crate) fn try_from_iter(iter: &mut SubtagIterator) -> Result<Self, ParserError> {
  let mut tlang = None;
  let mut tfields = LiteMap::new();

components/locid/src/extensions/unicode/mod.rs

@@ -32,6 +32,8 @@ mod key;
 mod keywords;
 mod value;
 
+use core::cmp::Ordering;
+
 #[doc(inline)]
 pub use attribute::{attribute, Attribute};
 pub use attributes::Attributes;
@@ -134,6 +136,20 @@ impl Unicode {
  self.attributes.clear();
  }
 
+ pub(crate) fn as_tuple(&self) -> (&Attributes, &Keywords) {
+ (&self.attributes, &self.keywords)
+ }
+
+ /// Returns an ordering suitable for use in [`BTreeSet`].
+ ///
+ /// The ordering may or may not be equivalent to string ordering, and it
+ /// may or may not be stable across ICU4X releases.
+ ///
+ /// [`BTreeSet`]: alloc::collections::BTreeSet
+ pub fn total_cmp(&self, other: &Self) -> Ordering {
+ self.as_tuple().cmp(&other.as_tuple())
+ }
+
  pub(crate) fn try_from_iter(iter: &mut SubtagIterator) -> Result<Self, ParserError> {
  let mut attributes = ShortBoxSlice::new();
 

components/locid/src/langid.rs

@@ -203,6 +203,27 @@ impl LanguageIdentifier {
  self.write_cmp_bytes(other)
  }
 
+ pub(crate) fn as_tuple(
+ &self,
+ ) -> (
+ subtags::Language,
+ Option<subtags::Script>,
+ Option<subtags::Region>,
+ &subtags::Variants,
+ ) {
+ (self.language, self.script, self.region, &self.variants)
+ }
+
+ /// Compare this [`LanguageIdentifier`] with another [`LanguageIdentifier`] field-by-field.
+ /// The result is a total ordering sufficient for use in a [`BTreeMap`].
+ ///
+ /// Unlike [`Self::strict_cmp`], this function's ordering may not equal string ordering.
+ ///
+ /// [`BTreeMap`]: alloc::collections::BTreeMap
+ pub fn total_cmp(&self, other: &Self) -> Ordering {
+ self.as_tuple().cmp(&other.as_tuple())
+ }
+
  /// Compare this [`LanguageIdentifier`] with an iterator of BCP-47 subtags.
  ///
  /// This function has the same equality semantics as [`LanguageIdentifier::strict_cmp`]. It is intended as

components/locid/src/locale.rs

@@ -196,6 +196,47 @@ impl Locale {
  self.write_cmp_bytes(other)
  }
 
+ #[allow(clippy::type_complexity)]
+ pub(crate) fn as_tuple(
+ &self,
+ ) -> (
+ (
+ subtags::Language,
+ Option<subtags::Script>,
+ Option<subtags::Region>,
+ &subtags::Variants,
+ ),
+ (
+ (
+ &extensions::unicode::Attributes,
+ &extensions::unicode::Keywords,
+ ),
+ (
+ Option<(
+ subtags::Language,
+ Option<subtags::Script>,
+ Option<subtags::Region>,
+ &subtags::Variants,
+ )>,
+ &extensions::transform::Fields,
+ ),
+ &extensions::private::Private,
+ &[extensions::other::Other],
+ ),
+ ) {
+ (self.id.as_tuple(), self.extensions.as_tuple())
+ }
+
+ /// Returns an ordering suitable for use in [`BTreeSet`].
+ ///
+ /// The ordering may or may not be equivalent to string ordering, and it
+ /// may or may not be stable across ICU4X releases.
+ ///
+ /// [`BTreeSet`]: alloc::collections::BTreeSet
+ pub fn total_cmp(&self, other: &Self) -> Ordering {
+ self.as_tuple().cmp(&other.as_tuple())
+ }
+
  /// Compare this [`Locale`] with an iterator of BCP-47 subtags.
  ///
  /// This function has the same equality semantics as [`Locale::strict_cmp`]. It is intended as

ffi/capi/src/locale.rs

@@ -178,6 +178,11 @@ pub mod ffi {
  self.0.strict_cmp(other).into()
  }
 
+ #[diplomat::rust_link(icu::locid::Locale::total_cmp, FnInStruct)]
+ pub fn total_cmp(&self, other: &Self) -> ICU4XOrdering {
+ self.0.total_cmp(&other.0).into()
+ }
+
  /// Deprecated
  ///
  /// Use `create_from_string("en").

provider/core/src/request.rs

@@ -370,6 +370,24 @@ impl DataLocale {
  self == <&DataLocale>::default()
  }
 
+ /// Returns an ordering suitable for use in [`BTreeSet`].
+ ///
+ /// The ordering may or may not be equivalent to string ordering, and it
+ /// may or may not be stable across ICU4X releases.
+ ///
+ /// [`BTreeSet`]: alloc::collections::BTreeSet
+ pub fn total_cmp(&self, other: &Self) -> Ordering {
+ self.langid
+ .total_cmp(&other.langid)
+ .then_with(|| self.keywords.cmp(&other.keywords))
+ .then_with(|| {
+ #[cfg(feature = "experimental")]
+ return self.aux.cmp(&other.aux);
+ #[cfg(not(feature = "experimental"))]
+ return Ordering::Equal;
+ })
+ }
+
  /// Returns whether this [`DataLocale`] is `und` in the locale and extensions portion.
  ///
  /// This ignores auxiliary keys.
@@ -752,7 +770,7 @@ impl DataLocale {
 /// ```
 ///
 /// [`Keywords`]: unicode_ext::Keywords
-#[derive(Debug, PartialEq, Clone, Eq, Hash)]
+#[derive(Debug, PartialEq, Clone, Eq, Hash, PartialOrd, Ord)]
 #[cfg(feature = "experimental")]
 pub struct AuxiliaryKeys {
  value: AuxiliaryKeysInner,
@@ -790,6 +808,20 @@ impl PartialEq for AuxiliaryKeysInner {
 #[cfg(feature = "experimental")]
 impl Eq for AuxiliaryKeysInner {}
 
+#[cfg(feature = "experimental")]
+impl PartialOrd for AuxiliaryKeysInner {
+ fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+ Some(self.cmp(other))
+ }
+}
+
+#[cfg(feature = "experimental")]
+impl Ord for AuxiliaryKeysInner {
+ fn cmp(&self, other: &Self) -> Ordering {
+ self.deref().cmp(other.deref())
+ }
+}
+
 #[cfg(feature = "experimental")]
 impl Debug for AuxiliaryKeysInner {
  #[inline]