| Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/C/Firefox/third_party/rust/icu_properties/src/ (Firefox Browser Version 136.0.1©) Datei vom 10.2.2025 mit Größe 122 kB |
|
Quelle props.rsSprache: Rust |
|||||||||||||||
|
// 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 ). //! A collection of property definitions shared across contexts //! (ex: representing trie values). //! //! This module defines enums / newtypes for enumerated properties. //! String properties are represented as newtypes if their //! values represent code points. use crate::provider::{names::*, *}; use crate::PropertiesError; use core::marker::PhantomData; use icu_collections::codepointtrie::TrieValue; use icu_provider::prelude::*; use zerovec::ule::VarULE; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; /// Private marker type for PropertyValueNameToEnumMapper /// to work for all properties at once #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)] pub(crate) struct ErasedNameToEnumMapV1Marker; impl DataMarker for ErasedNameToEnumMapV1Marker { type Yokeable = PropertyValueNameToEnumMapV1<'static>; } /// A struct capable of looking up a property value from a string name. /// Access its data by calling [`Self::as_borrowed()`] and using the methods on /// [`PropertyValueNameToEnumMapperBorrowed`]. /// /// The name can be a short name (`Lu`), a long name(`Uppercase_Letter`), /// or an alias. /// /// Property names can be looked up using "strict" matching (looking for a name /// that matches exactly), or "loose matching", where the name is allowed to deviate /// in terms of ASCII casing, whitespace, underscores, and hyphens. /// /// # Example /// /// ``` /// use icu::properties::GeneralCategory; /// /// let lookup = GeneralCategory::name_to_enum_mapper(); /// // short name for value /// assert_eq!( /// lookup.get_strict("Lu"), /// Some(GeneralCategory::UppercaseLetter) /// ); /// assert_eq!( /// lookup.get_strict("Pd"), /// Some(GeneralCategory::DashPunctuation) /// ); /// // long name for value /// assert_eq!( /// lookup.get_strict("Uppercase_Letter"), /// Some(GeneralCategory::UppercaseLetter) /// ); /// assert_eq!( /// lookup.get_strict("Dash_Punctuation"), /// Some(GeneralCategory::DashPunctuation) /// ); /// // name has incorrect casing /// assert_eq!(lookup.get_strict("dashpunctuation"), None); /// // loose matching of name /// assert_eq!( /// lookup.get_loose("dash-punctuation"), /// Some(GeneralCategory::DashPunctuation) /// ); /// // fake property /// assert_eq!(lookup.get_strict("Animated_Gif"), None); /// ``` #[derive(Debug)] pub struct PropertyValueNameToEnumMapper<T> { map: DataPayload<ErasedNameToEnumMapV1Marker>, markers: PhantomData<fn() -> T>, } /// A borrowed wrapper around property value name-to-enum data, returned by /// [`PropertyValueNameToEnumMapper::as_borrowed()`]. More efficient to query. #[derive(Debug, Copy, Clone)] pub struct PropertyValueNameToEnumMapperBorrowed<'a, T> { map: &'a PropertyValueNameToEnumMapV1<'a>, markers: PhantomData<fn() -> T>, } impl<T: TrieValue> PropertyValueNameToEnumMapper<T> { /// Construct a borrowed version of this type that can be queried. /// /// This avoids a potential small underlying cost per API call (like `get_strict()`) by consol /// up front. #[inline] pub fn as_borrowed(&self) -> PropertyValueNameToEnumMapperBorro PropertyValueNameToEnumMapperBorrowed { map: self.map.get(), markers: PhantomData, } } pub(crate) fn from_data<M>(data: DataPayload<M>) -> Self where M: DataMarker<Yokeable = PropertyValueNameToEnumMapV1<'static>>, { Self { map: data.cast(), markers: PhantomData, } } #[doc(hidden)] // used by FFI code pub fn erase(self) -> PropertyValueNameToEnumMapper<u16> { PropertyValueNameToEnumMapper { map: self.map.cast(), markers: PhantomData, } } } impl<T: TrieValue> PropertyValueNameToEnumMapperBorrowed<'_, T> { /// Get the property value as a u16, doing a strict search looking for /// names that match exactly /// /// # Example /// /// ``` /// use icu::properties::GeneralCategory; /// /// let lookup = GeneralCategory::name_to_enum_mapper(); /// assert_eq!( /// lookup.get_strict_u16("Lu"), /// Some(GeneralCategory::UppercaseLetter as u16) /// ); /// assert_eq!( /// lookup.get_strict_u16("Uppercase_Letter"), /// Some(GeneralCategory::UppercaseLetter as u16) /// ); /// // does not do loose matching /// assert_eq!(lookup.get_strict_u16("UppercaseLetter"), None); /// ``` #[inline] pub fn get_strict_u16(&self, name: &str) -> Option<u16> { get_strict_u16(self.map, name) } /// Get the property value as a `T`, doing a strict search looking for /// names that match exactly /// /// # Example /// /// ``` /// use icu::properties::GeneralCategory; /// /// let lookup = GeneralCategory::name_to_enum_mapper(); /// assert_eq!( /// lookup.get_strict("Lu"), /// Some(GeneralCategory::UppercaseLetter) /// ); /// assert_eq!( /// lookup.get_strict("Uppercase_Letter"), /// Some(GeneralCategory::UppercaseLetter) /// ); /// // does not do loose matching /// assert_eq!(lookup.get_strict("UppercaseLetter"), None); /// ``` #[inline] pub fn get_strict(&self, name: &str) -> Option<T> { T::try_from_u32(self.get_strict_u16(name)? as u32).ok() } /// Get the property value as a u16, doing a loose search looking for /// names that match case-insensitively, ignoring ASCII hyphens, underscores, and /// whitespaces. /// /// # Example /// /// ``` /// use icu::properties::GeneralCategory; /// /// let lookup = GeneralCategory::name_to_enum_mapper(); /// assert_eq!( /// lookup.get_loose_u16("Lu"), /// Some(GeneralCategory::UppercaseLetter as u16) /// ); /// assert_eq!( /// lookup.get_loose_u16("Uppercase_Letter"), /// Some(GeneralCategory::UppercaseLetter as u16) /// ); /// // does do loose matching /// assert_eq!( /// lookup.get_loose_u16("UppercaseLetter"), /// Some(GeneralCategory::UppercaseLetter as u16) /// ); /// ``` #[inline] pub fn get_loose_u16(&self, name: &str) -> Option<u16> { get_loose_u16(self.map, name) } /// Get the property value as a `T`, doing a loose search looking for /// names that match case-insensitively, ignoring ASCII hyphens, underscores, and /// whitespaces. /// /// # Example /// /// ``` /// use icu::properties::GeneralCategory; /// /// let lookup = GeneralCategory::name_to_enum_mapper(); /// assert_eq!( /// lookup.get_loose("Lu"), /// Some(GeneralCategory::UppercaseLetter) /// ); /// assert_eq!( /// lookup.get_loose("Uppercase_Letter"), /// Some(GeneralCategory::UppercaseLetter) /// ); /// // does do loose matching /// assert_eq!( /// lookup.get_loose("UppercaseLetter"), /// Some(GeneralCategory::UppercaseLetter) /// ); /// ``` #[inline] pub fn get_loose(&self, name: &str) -> Option<T> { T::try_from_u32(self.get_loose_u16(name)? as u32).ok() } } impl<T: TrieValue> PropertyValueNameToEnumMapperBorrowed<'static, T> { /// Cheaply converts a [`PropertyValueNameToEnumMapperBorrowed<'static>`] into a [`Proper /// /// Note: Due to branching and indirection, using [`PropertyValueNameToEnumMapper`] might /// compile-time optimizations that are possible with [`PropertyValueNameToEnumMapperBo pub const fn static_to_owned(self) -> PropertyValueNameToEnumMapper<T> { PropertyValueNameToEnumMapper { map: DataPayload::from_static_ref(self.map), markers: PhantomData, } } } /// Avoid monomorphizing multiple copies of this function fn get_strict_u16(payload: &PropertyValueNameToEnumMapV1<'_>, name: &str) -> Option<u16> { // NormalizedPropertyName has no invariants so this should be free, but // avoid introducing a panic regardless let name = NormalizedPropertyNameStr::parse_byte_slice(name.as_bytes()).ok()?; payload.map.get_copied(name) } /// Avoid monomorphizing multiple copies of this function fn get_loose_u16(payload: &PropertyValueNameToEnumMapV1<'_>, name: &str) -> Option<u16> { // NormalizedPropertyName has no invariants so this should be free, but // avoid introducing a panic regardless let name = NormalizedPropertyNameStr::parse_byte_slice(name.as_bytes()).ok()?; payload.map.get_copied_by(|p| p.cmp_loose(name)) } /// Private marker type for PropertyEnumToValueNameSparseMapper /// to work for all properties at once #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)] pub(crate) struct ErasedEnumToValueNameSparseMapV1Marker; impl DataMarker for ErasedEnumToValueNameSparseMapV1Marker { type Yokeable = PropertyEnumToValueNameSparseMapV1<'static>; } /// A struct capable of looking up a property name from a value /// Access its data by calling [`Self::as_borrowed()`] and using the methods on /// [`PropertyEnumToValueNameSparseMapperBorrowed`]. /// /// This mapper is used for properties with sparse values, like [`CanonicalCombiningClass`] /// It may be obtained using methods like [`CanonicalCombiningClass::get_enum_to_long_na /// /// The name returned may be a short (`"KV"`) or long (`"Kana_Voicing"`) name, depending /// on the constructor used. /// /// # Example /// /// ``` /// use icu::properties::CanonicalCombiningClass; /// /// let lookup = CanonicalCombiningClass::enum_to_long_name_mapper(); /// assert_eq!( /// lookup.get(CanonicalCombiningClass::KanaVoicing), /// Some("Kana_Voicing") /// ); /// assert_eq!( /// lookup.get(CanonicalCombiningClass::AboveLeft), /// Some("Above_Left") /// ); /// ``` #[derive(Debug)] pub struct PropertyEnumToValueNameSparseMapper<T> { map: DataPayload<ErasedEnumToValueNameSparseMapV1Marker>, markers: PhantomData<fn(T) -> ()>, } /// A borrowed wrapper around property value name-to-enum data, returned by /// [`PropertyEnumToValueNameSparseMapper::as_borrowed()`]. More efficient to query. #[derive(Debug, Copy, Clone)] pub struct PropertyEnumToValueNameSparseMapperBorrowed<'a, T> { map: &'a PropertyEnumToValueNameSparseMapV1<'a>, markers: PhantomData<fn(T) -> ()>, } impl<T: TrieValue> PropertyEnumToValueNameSparseMapper<T> { /// Construct a borrowed version of this type that can be queried. /// /// This avoids a potential small underlying cost per API call (like `get_static()`) by consol /// up front. #[inline] pub fn as_borrowed(&self) -> PropertyEnumToValueNameSparseMappe PropertyEnumToValueNameSparseMapperBorrowed { map: self.map.get(), markers: PhantomData, } } /// Construct a new one from loaded data /// /// Typically it is preferable to use methods on individual property value types /// (like [`Script::TBD()`]) instead. pub(crate) fn from_data<M>(data: DataPayload<M>) -> Self where M: DataMarker<Yokeable = PropertyEnumToValueNameSparseMapV1<'static>>, { Self { map: data.cast(), markers: PhantomData, } } } impl<T: TrieValue> PropertyEnumToValueNameSparseMapperBorrowed<'_, T> { /// Get the property name given a value /// /// # Example /// /// ```rust /// use icu::properties::CanonicalCombiningClass; /// /// let lookup = CanonicalCombiningClass::enum_to_long_name_mapper(); /// assert_eq!( /// lookup.get(CanonicalCombiningClass::KanaVoicing), /// Some("Kana_Voicing") /// ); /// assert_eq!( /// lookup.get(CanonicalCombiningClass::AboveLeft), /// Some("Above_Left") /// ); /// ``` #[inline] pub fn get(&self, property: T) -> Option<&str> { let prop = u16::try_from(property.to_u32()).ok()?; self.map.map.get(&prop) } } impl<T: TrieValue> PropertyEnumToValueNameSparseMapperBorrowed<'static, T> { /// Cheaply converts a [`PropertyEnumToValueNameSparseMapperBorrowed<'static>`] into a [` /// /// Note: Due to branching and indirection, using [`PropertyEnumToValueNameSparseMapper` /// compile-time optimizations that are possible with [`PropertyEnumToValueNameSparseMa pub const fn static_to_owned(self) -> PropertyEnumToValueNameSparseMapper<T> { PropertyEnumToValueNameSparseMapper { map: DataPayload::from_static_ref(self.map), markers: PhantomData, } } } /// Private marker type for PropertyEnumToValueNameLinearMapper /// to work for all properties at once #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)] pub(crate) struct ErasedEnumToValueNameLinearMapV1Marker; impl DataMarker for ErasedEnumToValueNameLinearMapV1Marker { type Yokeable = PropertyEnumToValueNameLinearMapV1<'static>; } /// A struct capable of looking up a property name from a value /// Access its data by calling [`Self::as_borrowed()`] and using the methods on /// [`PropertyEnumToValueNameLinearMapperBorrowed`]. /// /// This mapper is used for properties with sequential values, like [`GeneralCategory`]. /// It may be obtained using methods like [`GeneralCategory::get_enum_to_long_name_mappe /// /// The name returned may be a short (`"Lu"`) or long (`"Uppercase_Letter"`) name, depending /// on the constructor used. /// /// # Example /// /// ``` /// use icu::properties::GeneralCategory; /// /// let lookup = GeneralCategory::enum_to_long_name_mapper(); /// assert_eq!( /// lookup.get(GeneralCategory::UppercaseLetter), /// Some("Uppercase_Letter") /// ); /// assert_eq!( /// lookup.get(GeneralCategory::DashPunctuation), /// Some("Dash_Punctuation") /// ); /// ``` #[derive(Debug)] pub struct PropertyEnumToValueNameLinearMapper<T> { map: DataPayload<ErasedEnumToValueNameLinearMapV1Marker>, markers: PhantomData<fn(T) -> ()>, } /// A borrowed wrapper around property value name-to-enum data, returned by /// [`PropertyEnumToValueNameLinearMapper::as_borrowed()`]. More efficient to query. #[derive(Debug, Copy, Clone)] pub struct PropertyEnumToValueNameLinearMapperBorrowed<'a, T> { map: &'a PropertyEnumToValueNameLinearMapV1<'a>, markers: PhantomData<fn(T) -> ()>, } impl<T: TrieValue> PropertyEnumToValueNameLinearMapper<T> { /// Construct a borrowed version of this type that can be queried. /// /// This avoids a potential small underlying cost per API call (like `get_static()`) by consol /// up front. #[inline] pub fn as_borrowed(&self) -> PropertyEnumToValueNameLinearMappe PropertyEnumToValueNameLinearMapperBorrowed { map: self.map.get(), markers: PhantomData, } } /// Construct a new one from loaded data /// /// Typically it is preferable to use methods on individual property value types /// (like [`Script::TBD()`]) instead. pub(crate) fn from_data<M>(data: DataPayload<M>) -> Self where M: DataMarker<Yokeable = PropertyEnumToValueNameLinearMapV1<'static>>, { Self { map: data.cast(), markers: PhantomData, } } } impl<T: TrieValue> PropertyEnumToValueNameLinearMapperBorrowed<'_, T> { /// Get the property name given a value /// /// # Example /// /// ```rust /// use icu::properties::GeneralCategory; /// /// let lookup = GeneralCategory::enum_to_short_name_mapper(); /// assert_eq!(lookup.get(GeneralCategory::UppercaseLetter), Some("Lu")); /// assert_eq!(lookup.get(GeneralCategory::DashPunctuation), Some("Pd")); /// ``` #[inline] pub fn get(&self, property: T) -> Option<&str> { let prop = usize::try_from(property.to_u32()).ok()?; self.map.map.get(prop).filter(|x| !x.is_empty()) } } impl<T: TrieValue> PropertyEnumToValueNameLinearMapperBorrowed<'static, T> { /// Cheaply converts a [`PropertyEnumToValueNameLinearMapperBorrowed<'static>`] into a [` /// /// Note: Due to branching and indirection, using [`PropertyEnumToValueNameLinearMapper` /// compile-time optimizations that are possible with [`PropertyEnumToValueNameLinearMa pub const fn static_to_owned(self) -> PropertyEnumToValueNameLinearMapper<T> { PropertyEnumToValueNameLinearMapper { map: DataPayload::from_static_ref(self.map), markers: PhantomData, } } } /// Private marker type for PropertyEnumToValueNameLinearTiny4Mapper /// to work for all properties at once #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)] pub(crate) struct ErasedEnumToValueNameLinearTiny4MapV1Marker; impl DataMarker for ErasedEnumToValueNameLinearTiny4MapV1Marker { type Yokeable = PropertyEnumToValueNameLinearTiny4MapV1<'static>; } /// A struct capable of looking up a property name from a value /// Access its data by calling [`Self::as_borrowed()`] and using the methods on /// [`PropertyEnumToValueNameLinearTiny4MapperBorrowed`]. /// /// This mapper is used for properties with sequential values and names with four or fewer chara /// like the [`Script`] short names. /// It may be obtained using methods like [`Script::get_enum_to_short_name_mapper()`]. /// /// # Example /// /// ``` /// use icu::properties::Script; /// use tinystr::tinystr; /// /// let lookup = Script::enum_to_short_name_mapper(); /// assert_eq!(lookup.get(Script::Brahmi), Some(tinystr!(4, "Brah"))); /// assert_eq!(lookup.get(Script::Hangul), Some(tinystr!(4, "Hang"))); /// ``` #[derive(Debug)] pub struct PropertyEnumToValueNameLinearTiny4Mapper<T> { map: DataPayload<ErasedEnumToValueNameLinearTiny4MapV1Marker>, markers: PhantomData<fn(T) -> ()>, } /// A borrowed wrapper around property value name-to-enum data, returned by /// [`PropertyEnumToValueNameLinearTiny4Mapper::as_borrowed()`]. More efficient to qu #[derive(Debug, Copy, Clone)] pub struct PropertyEnumToValueNameLinearTiny4MapperBorrowed<'a, T> { map: &'a PropertyEnumToValueNameLinearTiny4MapV1<'a>, markers: PhantomData<fn(T) -> ()>, } impl<T: TrieValue> PropertyEnumToValueNameLinearTiny4Mapper<T> { /// Construct a borrowed version of this type that can be queried. /// /// This avoids a potential small underlying cost per API call (like `get_static()`) by consol /// up front. #[inline] pub fn as_borrowed(&self) -> PropertyEnumToValueNameLinearTiny4 PropertyEnumToValueNameLinearTiny4MapperBorrowed { map: self.map.get(), markers: PhantomData, } } /// Construct a new one from loaded data /// /// Typically it is preferable to use methods on individual property value types /// (like [`Script::TBD()`]) instead. pub(crate) fn from_data<M>(data: DataPayload<M>) -> Self where M: DataMarker<Yokeable = PropertyEnumToValueNameLinearTiny4MapV1<'static>>, { Self { map: data.cast(), markers: PhantomData, } } } impl<T: TrieValue> PropertyEnumToValueNameLinearTiny4MapperBorrowed<'_, T> { /// Get the property name given a value /// /// # Example /// /// ```rust /// use icu::properties::Script; /// use tinystr::tinystr; /// /// let lookup = Script::enum_to_short_name_mapper(); /// assert_eq!(lookup.get(Script::Brahmi), Some(tinystr!(4, "Brah"))); /// assert_eq!(lookup.get(Script::Hangul), Some(tinystr!(4, "Hang"))); /// ``` #[inline] pub fn get(&self, property: T) -> Option<tinystr::TinyStr4> { let prop = usize::try_from(property.to_u32()).ok()?; self.map.map.get(prop).filter(|x| !x.is_empty()) } } impl<T: TrieValue> PropertyEnumToValueNameLinearTiny4MapperBorrowed<'static, T> { /// Cheaply converts a [`PropertyEnumToValueNameLinearTiny4MapperBorrowed<'static>`] in /// /// Note: Due to branching and indirection, using [`PropertyEnumToValueNameLinearTiny4Ma /// compile-time optimizations that are possible with [`PropertyEnumToValueNameLinearTi pub const fn static_to_owned(self) -> PropertyEnumToValueNameLinearTiny4Mapper<T> { PropertyEnumToValueNameLinearTiny4Mapper { map: DataPayload::from_static_ref(self.map), markers: PhantomData, } } } macro_rules! impl_value_getter { ( // the marker type for names lookup (name_to_enum, enum_to_short_name, enum_to_long_name) markers: $marker_n2e:ident / $singleton_n2e:ident $(, $marker_e2sn:ident / $singleton_e impl $ty:ident { $(#[$attr_n2e:meta])* $vis_n2e:vis fn $name_n2e:ident() / $cname_n2e:ident(); $( $(#[$attr_e2sn:meta])* $vis_e2sn:vis fn $name_e2sn:ident() / $cname_e2sn:ident() -> $mapper_e2sn:ident / $mapper $(#[$attr_e2ln:meta])* $vis_e2ln:vis fn $name_e2ln:ident() / $cname_e2ln:ident() -> $mapper_e2ln:ident / $mapper )? } ) => { impl $ty { $(#[$attr_n2e])* #[cfg(feature = "compiled_data")] $vis_n2e const fn $cname_n2e() -> PropertyValueNameToEnumMapperBorrowed<'static, $ty> { PropertyValueNameToEnumMapperBorrowed { map: crate::provider::Baked::$singleton_n2e, markers: PhantomData, } } #[doc = concat!("A version of [`", stringify!($ty), "::", stringify!($cname_n2e), "()`] th /// /// [�� Help choosing a constructor](icu_provider::constructors) $vis_n2e fn $name_n2e( provider: &(impl DataProvider<$marker_n2e> + ?Sized) ) -> Result<PropertyValueNameToEnumMapper<$ty>, PropertiesError> { Ok(provider.load(Default::default()).and_then(DataResponse::take_payload).map(Pr } $( $(#[$attr_e2sn])* #[cfg(feature = "compiled_data")] $vis_e2sn const fn $cname_e2sn() -> $mapper_e2snb<'static, $ty> { $mapper_e2snb { map: crate::provider::Baked::$singleton_e2sn, markers: PhantomData, } } #[doc = concat!("A version of [`", stringify!($ty), "::", stringify!($cname_e2sn), "()`] t /// /// [�� Help choosing a constructor](icu_provider::constructors) $vis_e2sn fn $name_e2sn( provider: &(impl DataProvider<$marker_e2sn> + ?Sized) ) -> Result<$mapper_e2sn<$ty>, PropertiesError> { Ok(provider.load(Default::default()).and_then(DataResponse::take_payload).map($m } $(#[$attr_e2ln])* #[cfg(feature = "compiled_data")] $vis_e2ln const fn $cname_e2ln() -> $mapper_e2lnb<'static, $ty> { $mapper_e2lnb { map: crate::provider::Baked::$singleton_e2ln, markers: PhantomData, } } #[doc = concat!("A version of [`", stringify!($ty), "::", stringify!($cname_e2ln), "()`] t /// /// [�� Help choosing a constructor](icu_provider::constructors) $vis_e2ln fn $name_e2ln( provider: &(impl DataProvider<$marker_e2ln> + ?Sized) ) -> Result<$mapper_e2ln<$ty>, PropertiesError> { Ok(provider.load(Default::default()).and_then(DataResponse::take_payload).map($m } )? } } } /// See [`test_enumerated_property_completeness`] for usage. /// Example input: /// ```ignore /// impl EastAsianWidth { /// pub const Neutral: EastAsianWidth = EastAsianWidth(0); /// pub const Ambiguous: EastAsianWidth = EastAsianWidth(1); /// ... /// } /// ``` /// Produces `const ALL_CONSTS = &[("Neutral", 0u16), ...];` by /// explicitly casting first field of the struct to u16. macro_rules! create_const_array { ( $ ( #[$meta:meta] )* impl $enum_ty:ident { $( $(#[$const_meta:meta])* $v:vis const $i:ident: $t:ty = $e:expr; )* } ) => { $( #[$meta] )* impl $enum_ty { $( $(#[$const_meta])* $v const $i: $t = $e; )* #[cfg(test)] const ALL_CONSTS: &'static [(&'static str, u16)] = &[ $((stringify!($i), $enum_ty::$i.0 as u16)),* ]; } } } /// Enumerated property Bidi_Class /// /// These are the categories required by the Unicode Bidirectional Algorithm. /// For the property values, see [Bidirectional Class Values](https://unicode.org/report /// For more information, see [Unicode Standard Annex #9](https://unicode.org/reports/tr #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "datagen", derive(databake::Bake))] #[cfg_attr(feature = "datagen", databake(path = icu_properties))] #[allow(clippy::exhaustive_structs)] // newtype #[repr(transparent)] #[zerovec::make_ule(BidiClassULE)] pub struct BidiClass(pub u8); create_const_array! { #[allow(non_upper_case_globals)] impl BidiClass { /// (`L`) any strong left-to-right character pub const LeftToRight: BidiClass = BidiClass(0); /// (`R`) any strong right-to-left (non-Arabic-type) character pub const RightToLeft: BidiClass = BidiClass(1); /// (`EN`) any ASCII digit or Eastern Arabic-Indic digit pub const EuropeanNumber: BidiClass = BidiClass(2); /// (`ES`) plus and minus signs pub const EuropeanSeparator: BidiClass = BidiClass(3); /// (`ET`) a terminator in a numeric format context, includes currency signs pub const EuropeanTerminator: BidiClass = BidiClass(4); /// (`AN`) any Arabic-Indic digit pub const ArabicNumber: BidiClass = BidiClass(5); /// (`CS`) commas, colons, and slashes pub const CommonSeparator: BidiClass = BidiClass(6); /// (`B`) various newline characters pub const ParagraphSeparator: BidiClass = BidiClass(7); /// (`S`) various segment-related control codes pub const SegmentSeparator: BidiClass = BidiClass(8); /// (`WS`) spaces pub const WhiteSpace: BidiClass = BidiClass(9); /// (`ON`) most other symbols and punctuation marks pub const OtherNeutral: BidiClass = BidiClass(10); /// (`LRE`) U+202A: the LR embedding control pub const LeftToRightEmbedding: BidiClass = BidiClass(11); /// (`LRO`) U+202D: the LR override control pub const LeftToRightOverride: BidiClass = BidiClass(12); /// (`AL`) any strong right-to-left (Arabic-type) character pub const ArabicLetter: BidiClass = BidiClass(13); /// (`RLE`) U+202B: the RL embedding control pub const RightToLeftEmbedding: BidiClass = BidiClass(14); /// (`RLO`) U+202E: the RL override control pub const RightToLeftOverride: BidiClass = BidiClass(15); /// (`PDF`) U+202C: terminates an embedding or override control pub const PopDirectionalFormat: BidiClass = BidiClass(16); /// (`NSM`) any nonspacing mark pub const NonspacingMark: BidiClass = BidiClass(17); /// (`BN`) most format characters, control codes, or noncharacters pub const BoundaryNeutral: BidiClass = BidiClass(18); /// (`FSI`) U+2068: the first strong isolate control pub const FirstStrongIsolate: BidiClass = BidiClass(19); /// (`LRI`) U+2066: the LR isolate control pub const LeftToRightIsolate: BidiClass = BidiClass(20); /// (`RLI`) U+2067: the RL isolate control pub const RightToLeftIsolate: BidiClass = BidiClass(21); /// (`PDI`) U+2069: terminates an isolate control pub const PopDirectionalIsolate: BidiClass = BidiClass(22); } } impl_value_getter! { markers: BidiClassNameToValueV1Marker / SINGLETON_PROPNAMES_FROM_BC_V1, BidiClassVal impl BidiClass { /// Return a [`PropertyValueNameToEnumMapper`], capable of looking up values /// from strings for the `Bidi_Class` enumerated property /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::BidiClass; /// /// let lookup = BidiClass::name_to_enum_mapper(); /// // short name for value /// assert_eq!(lookup.get_strict("AN"), Some(BidiClass::ArabicNumber)); /// assert_eq!(lookup.get_strict("NSM"), Some(BidiClass::NonspacingMark)); /// // long name for value /// assert_eq!(lookup.get_strict("Arabic_Number"), Some(BidiClass::ArabicNumber)); /// assert_eq!(lookup.get_strict("Nonspacing_Mark"), Some(BidiClass::NonspacingMar /// // name has incorrect casing /// assert_eq!(lookup.get_strict("arabicnumber"), None); /// // loose matching of name /// assert_eq!(lookup.get_loose("arabicnumber"), Some(BidiClass::ArabicNumber)); /// // fake property /// assert_eq!(lookup.get_strict("Upside_Down_Vertical_Backwards_Mirrored"), None) /// ``` pub fn get_name_to_enum_mapper() / name_to_enum_mapper(); /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up short names /// for values of the `Bidi_Class` enumerated property /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::BidiClass; /// /// let lookup = BidiClass::enum_to_short_name_mapper(); /// assert_eq!(lookup.get(BidiClass::ArabicNumber), Some("AN")); /// assert_eq!(lookup.get(BidiClass::NonspacingMark), Some("NSM")); /// ``` pub fn get_enum_to_short_name_mapper() / enum_to_short_name_mapper() -> PropertyEnumToV /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up long names /// for values of the `Bidi_Class` enumerated property /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::BidiClass; /// /// let lookup = BidiClass::enum_to_long_name_mapper(); /// assert_eq!(lookup.get(BidiClass::ArabicNumber), Some("Arabic_Number")); /// assert_eq!(lookup.get(BidiClass::NonspacingMark), Some("Nonspacing_Mark")); /// ``` pub fn get_enum_to_long_name_mapper() / enum_to_long_name_mapper() -> PropertyEnumToVal } } /// Enumerated property General_Category. /// /// General_Category specifies the most general classification of a code point, usually /// determined based on the primary characteristic of the assigned character. For example, is /// character a letter, a mark, a number, punctuation, or a symbol, and if so, of what type? /// /// GeneralCategory only supports specific subcategories (eg `UppercaseLetter`). /// It does not support grouped categories (eg `Letter`). For grouped categories, use [`Gener #[derive(Copy, Clone, PartialEq, Eq, Debug, Ord, PartialOrd, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "datagen", derive(databake::Bake))] #[cfg_attr(feature = "datagen", databake(path = icu_properties))] #[allow(clippy::exhaustive_enums)] // this type is stable #[zerovec::make_ule(GeneralCategoryULE)] #[repr(u8)] pub enum GeneralCategory { /// (`Cn`) A reserved unassigned code point or a noncharacter Unassigned = 0, /// (`Lu`) An uppercase letter UppercaseLetter = 1, /// (`Ll`) A lowercase letter LowercaseLetter = 2, /// (`Lt`) A digraphic letter, with first part uppercase TitlecaseLetter = 3, /// (`Lm`) A modifier letter ModifierLetter = 4, /// (`Lo`) Other letters, including syllables and ideographs OtherLetter = 5, /// (`Mn`) A nonspacing combining mark (zero advance width) NonspacingMark = 6, /// (`Mc`) A spacing combining mark (positive advance width) SpacingMark = 8, /// (`Me`) An enclosing combining mark EnclosingMark = 7, /// (`Nd`) A decimal digit DecimalNumber = 9, /// (`Nl`) A letterlike numeric character LetterNumber = 10, /// (`No`) A numeric character of other type OtherNumber = 11, /// (`Zs`) A space character (of various non-zero widths) SpaceSeparator = 12, /// (`Zl`) U+2028 LINE SEPARATOR only LineSeparator = 13, /// (`Zp`) U+2029 PARAGRAPH SEPARATOR only ParagraphSeparator = 14, /// (`Cc`) A C0 or C1 control code Control = 15, /// (`Cf`) A format control character Format = 16, /// (`Co`) A private-use character PrivateUse = 17, /// (`Cs`) A surrogate code point Surrogate = 18, /// (`Pd`) A dash or hyphen punctuation mark DashPunctuation = 19, /// (`Ps`) An opening punctuation mark (of a pair) OpenPunctuation = 20, /// (`Pe`) A closing punctuation mark (of a pair) ClosePunctuation = 21, /// (`Pc`) A connecting punctuation mark, like a tie ConnectorPunctuation = 22, /// (`Pi`) An initial quotation mark InitialPunctuation = 28, /// (`Pf`) A final quotation mark FinalPunctuation = 29, /// (`Po`) A punctuation mark of other type OtherPunctuation = 23, /// (`Sm`) A symbol of mathematical use MathSymbol = 24, /// (`Sc`) A currency sign CurrencySymbol = 25, /// (`Sk`) A non-letterlike modifier symbol ModifierSymbol = 26, /// (`So`) A symbol of other type OtherSymbol = 27, } impl_value_getter! { markers: GeneralCategoryNameToValueV1Marker / SINGLETON_PROPNAMES_FROM_GC_V1, Genera impl GeneralCategory { /// Return a [`PropertyValueNameToEnumMapper`], capable of looking up values /// from strings for the `General_Category` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::GeneralCategory; /// /// let lookup = GeneralCategory::name_to_enum_mapper(); /// // short name for value /// assert_eq!(lookup.get_strict("Lu"), Some(GeneralCategory::UppercaseLetter)); /// assert_eq!(lookup.get_strict("Pd"), Some(GeneralCategory::DashPunctuation)); /// // long name for value /// assert_eq!(lookup.get_strict("Uppercase_Letter"), Some(GeneralCategory::Upperc /// assert_eq!(lookup.get_strict("Dash_Punctuation"), Some(GeneralCategory::DashPu /// // name has incorrect casing /// assert_eq!(lookup.get_strict("dashpunctuation"), None); /// // loose matching of name /// assert_eq!(lookup.get_loose("dash-punctuation"), Some(GeneralCategory::DashPun /// // fake property /// assert_eq!(lookup.get_loose("Animated_Gif"), None); /// ``` pub fn get_name_to_enum_mapper() / name_to_enum_mapper(); /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up short names /// for values of the `General_Category` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::GeneralCategory; /// /// let lookup = GeneralCategory::enum_to_short_name_mapper(); /// assert_eq!(lookup.get(GeneralCategory::UppercaseLetter), Some("Lu")); /// assert_eq!(lookup.get(GeneralCategory::DashPunctuation), Some("Pd")); /// assert_eq!(lookup.get(GeneralCategory::FinalPunctuation), Some("Pf")); /// ``` pub fn get_enum_to_short_name_mapper() / enum_to_short_name_mapper() -> PropertyEnumToV /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up long names /// for values of the `General_Category` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::GeneralCategory; /// /// let lookup = GeneralCategory::enum_to_long_name_mapper(); /// assert_eq!(lookup.get(GeneralCategory::UppercaseLetter), Some("Uppercase_Lette /// assert_eq!(lookup.get(GeneralCategory::DashPunctuation), Some("Dash_Punctuatio /// assert_eq!(lookup.get(GeneralCategory::FinalPunctuation), Some("Final_Punctuat /// ``` pub fn get_enum_to_long_name_mapper() / enum_to_long_name_mapper() -> PropertyEnumToVal } } #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash, Default)] pub struct GeneralCategoryTryFromError; impl TryFrom<u8> for GeneralCategory { type Error = GeneralCategoryTryFromError; /// Construct this [`GeneralCategory`] from an integer, returning /// an error if it is out of bounds fn try_from(val: u8) -> Result<Self, GeneralCategoryTryFromError> { GeneralCategory::new_from_u8(val).ok_or(GeneralCategoryTryFromError) } } /// Groupings of multiple General_Category property values. /// /// Instances of `GeneralCategoryGroup` represent the defined multi-category /// values that are useful for users in certain contexts, such as regex. In /// other words, unlike [`GeneralCategory`], this supports groups of general /// categories: for example, `Letter` /// is the union of `UppercaseLetter`, /// `LowercaseLetter`, etc. /// /// See <https://www.unicode.org/reports/tr44/> . /// /// The discriminants correspond to the `U_GC_XX_MASK` constants in ICU4C. /// Unlike [`GeneralCategory`], this supports groups of general categories: for example, `L /// is the union of `UppercaseLetter`, `LowercaseLetter`, etc. /// /// See `UCharCategory` and `U_GET_GC_MASK` in ICU4C. #[derive(Copy, Clone, PartialEq, Debug, Eq)] #[allow(clippy::exhaustive_structs)] // newtype #[repr(transparent)] pub struct GeneralCategoryGroup(pub(crate) u32); use GeneralCategory as GC; use GeneralCategoryGroup as GCG; #[allow(non_upper_case_globals)] impl GeneralCategoryGroup { /// (`Lu`) An uppercase letter pub const UppercaseLetter: GeneralCategoryGroup = GCG(1 << (GC::UppercaseLetter as u32)); /// (`Ll`) A lowercase letter pub const LowercaseLetter: GeneralCategoryGroup = GCG(1 << (GC::LowercaseLetter as u32)); /// (`Lt`) A digraphic letter, with first part uppercase pub const TitlecaseLetter: GeneralCategoryGroup = GCG(1 << (GC::TitlecaseLetter as u32)); /// (`Lm`) A modifier letter pub const ModifierLetter: GeneralCategoryGroup = GCG(1 << (GC::ModifierLetter as u32)); /// (`Lo`) Other letters, including syllables and ideographs pub const OtherLetter: GeneralCategoryGroup = GCG(1 << (GC::OtherLetter as u32)); /// (`LC`) The union of UppercaseLetter, LowercaseLetter, and TitlecaseLetter pub const CasedLetter: GeneralCategoryGroup = GCG(1 << (GC::UppercaseLetter as u32) | 1 << (GC::LowercaseLetter as u32) | 1 << (GC::TitlecaseLetter as u32)); /// (`L`) The union of all letter categories pub const Letter: GeneralCategoryGroup = GCG(1 << (GC::UppercaseLetter as u32) | 1 << (GC::LowercaseLetter as u32) | 1 << (GC::TitlecaseLetter as u32) | 1 << (GC::ModifierLetter as u32) | 1 << (GC::OtherLetter as u32)); /// (`Mn`) A nonspacing combining mark (zero advance width) pub const NonspacingMark: GeneralCategoryGroup = GCG(1 << (GC::NonspacingMark as u32)); /// (`Mc`) A spacing combining mark (positive advance width) pub const EnclosingMark: GeneralCategoryGroup = GCG(1 << (GC::EnclosingMark as u32)); /// (`Me`) An enclosing combining mark pub const SpacingMark: GeneralCategoryGroup = GCG(1 << (GC::SpacingMark as u32)); /// (`M`) The union of all mark categories pub const Mark: GeneralCategoryGroup = GCG(1 << (GC::NonspacingMark as u32) | 1 << (GC::EnclosingMark as u32) | 1 << (GC::SpacingMark as u32)); /// (`Nd`) A decimal digit pub const DecimalNumber: GeneralCategoryGroup = GCG(1 << (GC::DecimalNumber as u32)); /// (`Nl`) A letterlike numeric character pub const LetterNumber: GeneralCategoryGroup = GCG(1 << (GC::LetterNumber as u32)); /// (`No`) A numeric character of other type pub const OtherNumber: GeneralCategoryGroup = GCG(1 << (GC::OtherNumber as u32)); /// (`N`) The union of all number categories pub const Number: GeneralCategoryGroup = GCG(1 << (GC::DecimalNumber as u32) | 1 << (GC::LetterNumber as u32) | 1 << (GC::OtherNumber as u32)); /// (`Zs`) A space character (of various non-zero widths) pub const SpaceSeparator: GeneralCategoryGroup = GCG(1 << (GC::SpaceSeparator as u32)); /// (`Zl`) U+2028 LINE SEPARATOR only pub const LineSeparator: GeneralCategoryGroup = GCG(1 << (GC::LineSeparator as u32)); /// (`Zp`) U+2029 PARAGRAPH SEPARATOR only pub const ParagraphSeparator: GeneralCategoryGroup = GCG(1 << (GC::ParagraphSeparator as u3 /// (`Z`) The union of all separator categories pub const Separator: GeneralCategoryGroup = GCG(1 << (GC::SpaceSeparator as u32) | 1 << (GC::LineSeparator as u32) | 1 << (GC::ParagraphSeparator as u32)); /// (`Cc`) A C0 or C1 control code pub const Control: GeneralCategoryGroup = GCG(1 << (GC::Control as u32)); /// (`Cf`) A format control character pub const Format: GeneralCategoryGroup = GCG(1 << (GC::Format as u32)); /// (`Co`) A private-use character pub const PrivateUse: GeneralCategoryGroup = GCG(1 << (GC::PrivateUse as u32)); /// (`Cs`) A surrogate code point pub const Surrogate: GeneralCategoryGroup = GCG(1 << (GC::Surrogate as u32)); /// (`Cn`) A reserved unassigned code point or a noncharacter pub const Unassigned: GeneralCategoryGroup = GCG(1 << (GC::Unassigned as u32)); /// (`C`) The union of all control code, reserved, and unassigned categories pub const Other: GeneralCategoryGroup = GCG(1 << (GC::Control as u32) | 1 << (GC::Format as u32) | 1 << (GC::PrivateUse as u32) | 1 << (GC::Surrogate as u32) | 1 << (GC::Unassigned as u32)); /// (`Pd`) A dash or hyphen punctuation mark pub const DashPunctuation: GeneralCategoryGroup = GCG(1 << (GC::DashPunctuation as u32)); /// (`Ps`) An opening punctuation mark (of a pair) pub const OpenPunctuation: GeneralCategoryGroup = GCG(1 << (GC::OpenPunctuation as u32)); /// (`Pe`) A closing punctuation mark (of a pair) pub const ClosePunctuation: GeneralCategoryGroup = GCG(1 << (GC::ClosePunctuation as u32)); /// (`Pc`) A connecting punctuation mark, like a tie pub const ConnectorPunctuation: GeneralCategoryGroup = GCG(1 << (GC::ConnectorPunctuation as u32)); /// (`Pi`) An initial quotation mark pub const InitialPunctuation: GeneralCategoryGroup = GCG(1 << (GC::InitialPunctuation as u3 /// (`Pf`) A final quotation mark pub const FinalPunctuation: GeneralCategoryGroup = GCG(1 << (GC::FinalPunctuation as u32)); /// (`Po`) A punctuation mark of other type pub const OtherPunctuation: GeneralCategoryGroup = GCG(1 << (GC::OtherPunctuation as u32)); /// (`P`) The union of all punctuation categories pub const Punctuation: GeneralCategoryGroup = GCG(1 << (GC::DashPunctuation as u32) | 1 << (GC::OpenPunctuation as u32) | 1 << (GC::ClosePunctuation as u32) | 1 << (GC::ConnectorPunctuation as u32) | 1 << (GC::OtherPunctuation as u32) | 1 << (GC::InitialPunctuation as u32) | 1 << (GC::FinalPunctuation as u32)); /// (`Sm`) A symbol of mathematical use pub const MathSymbol: GeneralCategoryGroup = GCG(1 << (GC::MathSymbol as u32)); /// (`Sc`) A currency sign pub const CurrencySymbol: GeneralCategoryGroup = GCG(1 << (GC::CurrencySymbol as u32)); /// (`Sk`) A non-letterlike modifier symbol pub const ModifierSymbol: GeneralCategoryGroup = GCG(1 << (GC::ModifierSymbol as u32)); /// (`So`) A symbol of other type pub const OtherSymbol: GeneralCategoryGroup = GCG(1 << (GC::OtherSymbol as u32)); /// (`S`) The union of all symbol categories pub const Symbol: GeneralCategoryGroup = GCG(1 << (GC::MathSymbol as u32) | 1 << (GC::CurrencySymbol as u32) | 1 << (GC::ModifierSymbol as u32) | 1 << (GC::OtherSymbol as u32)); const ALL: u32 = (1 << (GC::FinalPunctuation as u32 + 1)) - 1; /// Return whether the code point belongs in the provided multi-value category. /// /// ``` /// use icu::properties::{maps, GeneralCategory, GeneralCategoryGroup}; /// /// let gc = maps::general_category(); /// /// assert_eq!(gc.get('A'), GeneralCategory::UppercaseLetter); /// assert!(GeneralCategoryGroup::CasedLetter.contains(gc.get('A'))); /// /// // U+0B1E ORIYA LETTER NYA /// assert_eq!(gc.get('ଞ'), GeneralCategory::OtherLetter); /// assert!(GeneralCategoryGroup::Letter.contains(gc.get('ଞ'))); /// assert!(!GeneralCategoryGroup::CasedLetter.contains(gc.get('ଞ'))); /// /// // U+0301 COMBINING ACUTE ACCENT /// assert_eq!(gc.get32(0x0301), GeneralCategory::NonspacingMark); /// assert!(GeneralCategoryGroup::Mark.contains(gc.get32(0x0301))); /// assert!(!GeneralCategoryGroup::Letter.contains(gc.get32(0x0301))); /// /// assert_eq!(gc.get('0'), GeneralCategory::DecimalNumber); /// assert!(GeneralCategoryGroup::Number.contains(gc.get('0'))); /// assert!(!GeneralCategoryGroup::Mark.contains(gc.get('0'))); /// /// assert_eq!(gc.get('('), GeneralCategory::OpenPunctuation); /// assert!(GeneralCategoryGroup::Punctuation.contains(gc.get('('))); /// assert!(!GeneralCategoryGroup::Number.contains(gc.get('('))); /// /// // U+2713 CHECK MARK /// assert_eq!(gc.get('✓'), GeneralCategory::OtherSymbol); /// assert!(GeneralCategoryGroup::Symbol.contains(gc.get('✓'))); /// assert!(!GeneralCategoryGroup::Punctuation.contains(gc.get('✓'))); /// /// assert_eq!(gc.get(' '), GeneralCategory::SpaceSeparator); /// assert!(GeneralCategoryGroup::Separator.contains(gc.get(' '))); /// assert!(!GeneralCategoryGroup::Symbol.contains(gc.get(' '))); /// /// // U+E007F CANCEL TAG /// assert_eq!(gc.get32(0xE007F), GeneralCategory::Format); /// assert!(GeneralCategoryGroup::Other.contains(gc.get32(0xE007F))); /// assert!(!GeneralCategoryGroup::Separator.contains(gc.get32(0xE007F))); /// ``` pub const fn contains(&self, val: GeneralCategory) -> bool { 0 != (1 << (val as u32)) & self.0 } /// Produce a GeneralCategoryGroup that is the inverse of this one /// /// # Example /// /// ```rust /// use icu::properties::{GeneralCategory, GeneralCategoryGroup}; /// /// let letter = GeneralCategoryGroup::Letter; /// let not_letter = letter.complement(); /// /// assert!(not_letter.contains(GeneralCategory::MathSymbol)); /// assert!(!letter.contains(GeneralCategory::MathSymbol)); /// assert!(not_letter.contains(GeneralCategory::OtherPunctuation)); /// assert!(!letter.contains(GeneralCategory::OtherPunctuation)); /// assert!(!not_letter.contains(GeneralCategory::UppercaseLetter)); /// assert!(letter.contains(GeneralCategory::UppercaseLetter)); /// ``` pub const fn complement(self) -> Self { // Mask off things not in Self::ALL to guarantee the mask // values stay in-range GeneralCategoryGroup(!self.0 & Self::ALL) } /// Return the group representing all GeneralCategory values /// /// # Example /// /// ```rust /// use icu::properties::{GeneralCategory, GeneralCategoryGroup}; /// /// let all = GeneralCategoryGroup::all(); /// /// assert!(all.contains(GeneralCategory::MathSymbol)); /// assert!(all.contains(GeneralCategory::OtherPunctuation)); /// assert!(all.contains(GeneralCategory::UppercaseLetter)); /// ``` pub const fn all() -> Self { Self(Self::ALL) } /// Return the empty group /// /// # Example /// /// ```rust /// use icu::properties::{GeneralCategory, GeneralCategoryGroup}; /// /// let empty = GeneralCategoryGroup::empty(); /// /// assert!(!empty.contains(GeneralCategory::MathSymbol)); /// assert!(!empty.contains(GeneralCategory::OtherPunctuation)); /// assert!(!empty.contains(GeneralCategory::UppercaseLetter)); /// ``` pub const fn empty() -> Self { Self(0) } /// Take the union of two groups /// /// # Example /// /// ```rust /// use icu::properties::{GeneralCategory, GeneralCategoryGroup}; /// /// let letter = GeneralCategoryGroup::Letter; /// let symbol = GeneralCategoryGroup::Symbol; /// let union = letter.union(symbol); /// /// assert!(union.contains(GeneralCategory::MathSymbol)); /// assert!(!union.contains(GeneralCategory::OtherPunctuation)); /// assert!(union.contains(GeneralCategory::UppercaseLetter)); /// ``` pub const fn union(self, other: Self) -> Self { Self(self.0 | other.0) } /// Take the intersection of two groups /// /// # Example /// /// ```rust /// use icu::properties::{GeneralCategory, GeneralCategoryGroup}; /// /// let letter = GeneralCategoryGroup::Letter; /// let lu = GeneralCategoryGroup::UppercaseLetter; /// let intersection = letter.intersection(lu); /// /// assert!(!intersection.contains(GeneralCategory::MathSymbol)); /// assert!(!intersection.contains(GeneralCategory::OtherPunctuation)); /// assert!(intersection.contains(GeneralCategory::UppercaseLetter)); /// assert!(!intersection.contains(GeneralCategory::LowercaseLetter)); /// ``` pub const fn intersection(self, other: Self) -> Self { Self(self.0 & other.0) } } impl_value_getter! { markers: GeneralCategoryMaskNameToValueV1Marker / SINGLETON_PROPNAMES_FROM_GCM_V1; impl GeneralCategoryGroup { /// Return a [`PropertyValueNameToEnumMapper`], capable of looking up values /// from strings for the `General_Category_Mask` mask property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::GeneralCategoryGroup; /// /// let lookup = GeneralCategoryGroup::name_to_enum_mapper(); /// // short name for value /// assert_eq!(lookup.get_strict("L"), Some(GeneralCategoryGroup::Letter)); /// assert_eq!(lookup.get_strict("LC"), Some(GeneralCategoryGroup::CasedLetter)); /// assert_eq!(lookup.get_strict("Lu"), Some(GeneralCategoryGroup::UppercaseLetter /// assert_eq!(lookup.get_strict("Zp"), Some(GeneralCategoryGroup::ParagraphSepara /// assert_eq!(lookup.get_strict("P"), Some(GeneralCategoryGroup::Punctuation)); /// // long name for value /// assert_eq!(lookup.get_strict("Letter"), Some(GeneralCategoryGroup::Letter)); /// assert_eq!(lookup.get_strict("Cased_Letter"), Some(GeneralCategoryGroup::Cased /// assert_eq!(lookup.get_strict("Uppercase_Letter"), Some(GeneralCategoryGroup::U /// // alias name /// assert_eq!(lookup.get_strict("punct"), Some(GeneralCategoryGroup::Punctuation) /// // name has incorrect casing /// assert_eq!(lookup.get_strict("letter"), None); /// // loose matching of name /// assert_eq!(lookup.get_loose("letter"), Some(GeneralCategoryGroup::Letter)); /// // fake property /// assert_eq!(lookup.get_strict("EverythingLol"), None); /// ``` pub fn get_name_to_enum_mapper() / name_to_enum_mapper(); } } impl From<GeneralCategory> for GeneralCategoryGroup { fn from(subcategory: GeneralCategory) -> Self { GeneralCategoryGroup(1 << (subcategory as u32)) } } impl From<u32> for GeneralCategoryGroup { fn from(mask: u32) -> Self { // Mask off things not in Self::ALL to guarantee the mask // values stay in-range GeneralCategoryGroup(mask & Self::ALL) } } impl From<GeneralCategoryGroup> for u32 { fn from(group: GeneralCategoryGroup) -> Self { group.0 } } /// Enumerated property Script. /// /// This is used with both the Script and Script_Extensions Unicode properties. /// Each character is assigned a single Script, but characters that are used in /// a particular subset of scripts will be in more than one Script_Extensions set. /// For example, DEVANAGARI DIGIT NINE has Script=Devanagari, but is also in the /// Script_Extensions set for Dogra, Kaithi, and Mahajani. /// /// For more information, see UAX #24: <http://www.unicode.org/reports/tr24/>. /// See `UScriptCode` in ICU4C. #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "datagen", derive(databake::Bake))] #[cfg_attr(feature = "datagen", databake(path = icu_properties))] #[allow(clippy::exhaustive_structs)] // newtype #[repr(transparent)] #[zerovec::make_ule(ScriptULE)] pub struct Script(pub u16); #[allow(missing_docs)] // These constants don't need individual documentation. #[allow(non_upper_case_globals)] impl Script { pub const Adlam: Script = Script(167); pub const Ahom: Script = Script(161); pub const AnatolianHieroglyphs: Script = Script(156); pub const Arabic: Script = Script(2); pub const Armenian: Script = Script(3); pub const Avestan: Script = Script(117); pub const Balinese: Script = Script(62); pub const Bamum: Script = Script(130); pub const BassaVah: Script = Script(134); pub const Batak: Script = Script(63); pub const Bengali: Script = Script(4); pub const Bhaiksuki: Script = Script(168); pub const Bopomofo: Script = Script(5); pub const Brahmi: Script = Script(65); pub const Braille: Script = Script(46); pub const Buginese: Script = Script(55); pub const Buhid: Script = Script(44); pub const CanadianAboriginal: Script = Script(40); pub const Carian: Script = Script(104); pub const CaucasianAlbanian: Script = Script(159); pub const Chakma: Script = Script(118); pub const Cham: Script = Script(66); pub const Cherokee: Script = Script(6); pub const Chorasmian: Script = Script(189); pub const Common: Script = Script(0); pub const Coptic: Script = Script(7); pub const Cuneiform: Script = Script(101); pub const Cypriot: Script = Script(47); pub const CyproMinoan: Script = Script(193); pub const Cyrillic: Script = Script(8); pub const Deseret: Script = Script(9); pub const Devanagari: Script = Script(10); pub const DivesAkuru: Script = Script(190); pub const Dogra: Script = Script(178); pub const Duployan: Script = Script(135); pub const EgyptianHieroglyphs: Script = Script(71); pub const Elbasan: Script = Script(136); pub const Elymaic: Script = Script(185); pub const Ethiopian: Script = Script(11); pub const Georgian: Script = Script(12); pub const Glagolitic: Script = Script(56); pub const Gothic: Script = Script(13); pub const Grantha: Script = Script(137); pub const Greek: Script = Script(14); pub const Gujarati: Script = Script(15); pub const GunjalaGondi: Script = Script(179); pub const Gurmukhi: Script = Script(16); pub const Han: Script = Script(17); pub const Hangul: Script = Script(18); pub const HanifiRohingya: Script = Script(182); pub const Hanunoo: Script = Script(43); pub const Hatran: Script = Script(162); pub const Hebrew: Script = Script(19); pub const Hiragana: Script = Script(20); pub const ImperialAramaic: Script = Script(116); pub const Inherited: Script = Script(1); pub const InscriptionalPahlavi: Script = Script(122); pub const InscriptionalParthian: Script = Script(125); pub const Javanese: Script = Script(78); pub const Kaithi: Script = Script(120); pub const Kannada: Script = Script(21); pub const Katakana: Script = Script(22); pub const Kawi: Script = Script(198); pub const KayahLi: Script = Script(79); pub const Kharoshthi: Script = Script(57); pub const KhitanSmallScript: Script = Script(191); pub const Khmer: Script = Script(23); pub const Khojki: Script = Script(157); pub const Khudawadi: Script = Script(145); pub const Lao: Script = Script(24); pub const Latin: Script = Script(25); pub const Lepcha: Script = Script(82); pub const Limbu: Script = Script(48); pub const LinearA: Script = Script(83); pub const LinearB: Script = Script(49); pub const Lisu: Script = Script(131); pub const Lycian: Script = Script(107); pub const Lydian: Script = Script(108); pub const Mahajani: Script = Script(160); pub const Makasar: Script = Script(180); pub const Malayalam: Script = Script(26); pub const Mandaic: Script = Script(84); pub const Manichaean: Script = Script(121); pub const Marchen: Script = Script(169); pub const MasaramGondi: Script = Script(175); pub const Medefaidrin: Script = Script(181); pub const MeeteiMayek: Script = Script(115); pub const MendeKikakui: Script = Script(140); pub const MeroiticCursive: Script = Script(141); pub const MeroiticHieroglyphs: Script = Script(86); pub const Miao: Script = Script(92); pub const Modi: Script = Script(163); pub const Mongolian: Script = Script(27); pub const Mro: Script = Script(149); pub const Multani: Script = Script(164); pub const Myanmar: Script = Script(28); pub const Nabataean: Script = Script(143); pub const NagMundari: Script = Script(199); pub const Nandinagari: Script = Script(187); pub const Nastaliq: Script = Script(200); pub const NewTaiLue: Script = Script(59); pub const Newa: Script = Script(170); pub const Nko: Script = Script(87); pub const Nushu: Script = Script(150); pub const NyiakengPuachueHmong: Script = Script(186); pub const Ogham: Script = Script(29); pub const OlChiki: Script = Script(109); pub const OldHungarian: Script = Script(76); pub const OldItalic: Script = Script(30); pub const OldNorthArabian: Script = Script(142); pub const OldPermic: Script = Script(89); pub const OldPersian: Script = Script(61); pub const OldSogdian: Script = Script(184); pub const OldSouthArabian: Script = Script(133); pub const OldTurkic: Script = Script(88); pub const OldUyghur: Script = Script(194); pub const Oriya: Script = Script(31); pub const Osage: Script = Script(171); pub const Osmanya: Script = Script(50); pub const PahawhHmong: Script = Script(75); pub const Palmyrene: Script = Script(144); pub const PauCinHau: Script = Script(165); pub const PhagsPa: Script = Script(90); pub const Phoenician: Script = Script(91); pub const PsalterPahlavi: Script = Script(123); pub const Rejang: Script = Script(110); pub const Runic: Script = Script(32); pub const Samaritan: Script = Script(126); pub const Saurashtra: Script = Script(111); pub const Sharada: Script = Script(151); pub const Shavian: Script = Script(51); pub const Siddham: Script = Script(166); pub const SignWriting: Script = Script(112); pub const Sinhala: Script = Script(33); pub const Sogdian: Script = Script(183); pub const SoraSompeng: Script = Script(152); pub const Soyombo: Script = Script(176); pub const Sundanese: Script = Script(113); pub const SylotiNagri: Script = Script(58); pub const Syriac: Script = Script(34); pub const Tagalog: Script = Script(42); pub const Tagbanwa: Script = Script(45); pub const TaiLe: Script = Script(52); pub const TaiTham: Script = Script(106); pub const TaiViet: Script = Script(127); pub const Takri: Script = Script(153); pub const Tamil: Script = Script(35); pub const Tangsa: Script = Script(195); pub const Tangut: Script = Script(154); pub const Telugu: Script = Script(36); pub const Thaana: Script = Script(37); pub const Thai: Script = Script(38); pub const Tibetan: Script = Script(39); pub const Tifinagh: Script = Script(60); pub const Tirhuta: Script = Script(158); pub const Toto: Script = Script(196); pub const Ugaritic: Script = Script(53); pub const Unknown: Script = Script(103); pub const Vai: Script = Script(99); pub const Vithkuqi: Script = Script(197); pub const Wancho: Script = Script(188); pub const WarangCiti: Script = Script(146); pub const Yezidi: Script = Script(192); pub const Yi: Script = Script(41); pub const ZanabazarSquare: Script = Script(177); } impl_value_getter! { markers: ScriptNameToValueV1Marker / SINGLETON_PROPNAMES_FROM_SC_V1, ScriptValueToSh impl Script { /// Return a [`PropertyValueNameToEnumMapper`], capable of looking up values /// from strings for the `Script` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::Script; /// /// let lookup = Script::name_to_enum_mapper(); /// // short name for value /// assert_eq!(lookup.get_strict("Brah"), Some(Script::Brahmi)); /// assert_eq!(lookup.get_strict("Hang"), Some(Script::Hangul)); /// // long name for value /// assert_eq!(lookup.get_strict("Brahmi"), Some(Script::Brahmi)); /// assert_eq!(lookup.get_strict("Hangul"), Some(Script::Hangul)); /// // name has incorrect casing /// assert_eq!(lookup.get_strict("brahmi"), None); /// // loose matching of name /// assert_eq!(lookup.get_loose("brahmi"), Some(Script::Brahmi)); /// // fake property /// assert_eq!(lookup.get_strict("Linear_Z"), None); /// ``` pub fn get_name_to_enum_mapper() / name_to_enum_mapper(); /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up short names /// for values of the `Script` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::Script; /// use tinystr::tinystr; /// /// let lookup = Script::enum_to_short_name_mapper(); /// assert_eq!(lookup.get(Script::Brahmi), Some(tinystr!(4, "Brah"))); /// assert_eq!(lookup.get(Script::Hangul), Some(tinystr!(4, "Hang"))); /// ``` pub fn get_enum_to_short_name_mapper() / enum_to_short_name_mapper() -> PropertyEnumToV /// Return a [`PropertyEnumToValueNameLinearTiny4Mapper`], capable of looking up long nam /// for values of the `Script` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::Script; /// /// let lookup = Script::enum_to_long_name_mapper(); /// assert_eq!(lookup.get(Script::Brahmi), Some("Brahmi")); /// assert_eq!(lookup.get(Script::Hangul), Some("Hangul")); /// ``` pub fn get_enum_to_long_name_mapper() / enum_to_long_name_mapper() -> PropertyEnumToVal } } /// Enumerated property Hangul_Syllable_Type /// /// The Unicode standard provides both precomposed Hangul syllables and conjoining Jamo to co /// arbitrary Hangul syllables. This property provies that ontology of Hangul code points. /// /// For more information, see the [Unicode Korean FAQ](https://www.unicode.org/faq/korea #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "datagen", derive(databake::Bake))] #[cfg_attr(feature = "datagen", databake(path = icu_properties))] #[allow(clippy::exhaustive_structs)] // newtype #[repr(transparent)] #[zerovec::make_ule(HangulSyllableTypeULE)] pub struct HangulSyllableType(pub u8); create_const_array! { #[allow(non_upper_case_globals)] impl HangulSyllableType { /// (`NA`) not applicable (e.g. not a Hangul code point). pub const NotApplicable: HangulSyllableType = HangulSyllableType(0); /// (`L`) a conjoining leading consonant Jamo. pub const LeadingJamo: HangulSyllableType = HangulSyllableType(1); /// (`V`) a conjoining vowel Jamo. pub const VowelJamo: HangulSyllableType = HangulSyllableType(2); /// (`T`) a conjoining trailing consonent Jamo. pub const TrailingJamo: HangulSyllableType = HangulSyllableType(3); /// (`LV`) a precomposed syllable with a leading consonant and a vowel. pub const LeadingVowelSyllable: HangulSyllableType = HangulSyllableType(4); /// (`LVT`) a precomposed syllable with a leading consonant, a vowel, and a trailing consonant pub const LeadingVowelTrailingSyllable: HangulSyllableType = HangulSyllableType(5); } } impl_value_getter! { markers: HangulSyllableTypeNameToValueV1Marker / SINGLETON_PROPNAMES_FROM_HST_V1, Ha impl HangulSyllableType { /// Return a [`PropertyValueNameToEnumMapper`], capable of looking up values /// from strings for the `Bidi_Class` enumerated property /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::HangulSyllableType; /// /// let lookup = HangulSyllableType::name_to_enum_mapper(); /// // short name for value /// assert_eq!(lookup.get_strict("L"), Some(HangulSyllableType::LeadingJamo)); /// assert_eq!(lookup.get_strict("LV"), Some(HangulSyllableType::LeadingVowelSylla /// // long name for value /// assert_eq!(lookup.get_strict("Leading_Jamo"), Some(HangulSyllableType::Leading /// assert_eq!(lookup.get_strict("LV_Syllable"), Some(HangulSyllableType::LeadingV /// // name has incorrect casing /// assert_eq!(lookup.get_strict("lv"), None); /// // loose matching of name /// assert_eq!(lookup.get_loose("lv"), Some(HangulSyllableType::LeadingVowelSyllab /// // fake property /// assert_eq!(lookup.get_strict("LT_Syllable"), None); /// ``` pub fn get_name_to_enum_mapper() / name_to_enum_mapper(); /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up short names /// for values of the `Bidi_Class` enumerated property /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::HangulSyllableType; /// /// let lookup = HangulSyllableType::enum_to_short_name_mapper(); /// assert_eq!(lookup.get(HangulSyllableType::LeadingJamo), Some("L")); /// assert_eq!(lookup.get(HangulSyllableType::LeadingVowelSyllable), Some("LV")); /// ``` pub fn get_enum_to_short_name_mapper() / enum_to_short_name_mapper() -> PropertyEnumToV /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up long names /// for values of the `Bidi_Class` enumerated property /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::HangulSyllableType; /// /// let lookup = HangulSyllableType::enum_to_long_name_mapper(); /// assert_eq!(lookup.get(HangulSyllableType::LeadingJamo), Some("Leading_Jamo")); /// assert_eq!(lookup.get(HangulSyllableType::LeadingVowelSyllable), Some("LV_Syll /// ``` pub fn get_enum_to_long_name_mapper() / enum_to_long_name_mapper() -> PropertyEnumToVal } } /// Enumerated property East_Asian_Width. /// /// See "Definition" in UAX #11 for the summary of each property value: /// <https://www.unicode.org/reports/tr11/#Definitions> /// /// The numeric value is compatible with `UEastAsianWidth` in ICU4C. #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "datagen", derive(databake::Bake))] #[cfg_attr(feature = "datagen", databake(path = icu_properties))] #[allow(clippy::exhaustive_structs)] // newtype #[repr(transparent)] #[zerovec::make_ule(EastAsianWidthULE)] pub struct EastAsianWidth(pub u8); create_const_array! { #[allow(missing_docs)] // These constants don't need individual documentation. #[allow(non_upper_case_globals)] impl EastAsianWidth { pub const Neutral: EastAsianWidth = EastAsianWidth(0); //name="N" pub const Ambiguous: EastAsianWidth = EastAsianWidth(1); //name="A" pub const Halfwidth: EastAsianWidth = EastAsianWidth(2); //name="H" pub const Fullwidth: EastAsianWidth = EastAsianWidth(3); //name="F" pub const Narrow: EastAsianWidth = EastAsianWidth(4); //name="Na" pub const Wide: EastAsianWidth = EastAsianWidth(5); //name="W" } } impl_value_getter! { markers: EastAsianWidthNameToValueV1Marker / SINGLETON_PROPNAMES_FROM_EA_V1, EastAsi impl EastAsianWidth { /// Return a [`PropertyValueNameToEnumMapper`], capable of looking up values /// from strings for the `East_Asian_Width` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::EastAsianWidth; /// /// let lookup = EastAsianWidth::name_to_enum_mapper(); /// // short name for value /// assert_eq!(lookup.get_strict("N"), Some(EastAsianWidth::Neutral)); /// assert_eq!(lookup.get_strict("H"), Some(EastAsianWidth::Halfwidth)); /// // long name for value /// assert_eq!(lookup.get_strict("Neutral"), Some(EastAsianWidth::Neutral)); /// assert_eq!(lookup.get_strict("Halfwidth"), Some(EastAsianWidth::Halfwidth)); /// // name has incorrect casing / extra hyphen /// assert_eq!(lookup.get_strict("half-width"), None); /// // loose matching of name /// assert_eq!(lookup.get_loose("half-width"), Some(EastAsianWidth::Halfwidth)); /// // fake property /// assert_eq!(lookup.get_strict("TwoPointFiveWidth"), None); /// ``` pub fn get_name_to_enum_mapper() / name_to_enum_mapper(); /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up short names /// for values of the `East_Asian_Width` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::EastAsianWidth; /// /// let lookup = EastAsianWidth::enum_to_short_name_mapper(); /// assert_eq!(lookup.get(EastAsianWidth::Neutral), Some("N")); /// assert_eq!(lookup.get(EastAsianWidth::Halfwidth), Some("H")); /// ``` pub fn get_enum_to_short_name_mapper() / enum_to_short_name_mapper() -> PropertyEnumToV /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up long names /// for values of the `East_Asian_Width` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::EastAsianWidth; /// /// let lookup = EastAsianWidth::enum_to_long_name_mapper(); /// assert_eq!(lookup.get(EastAsianWidth::Neutral), Some("Neutral")); /// assert_eq!(lookup.get(EastAsianWidth::Halfwidth), Some("Halfwidth")); /// ``` pub fn get_enum_to_long_name_mapper() / enum_to_long_name_mapper() -> PropertyEnumToVal } } /// Enumerated property Line_Break. /// /// See "Line Breaking Properties" in UAX #14 for the summary of each property /// value: <https://www.unicode.org/reports/tr14/#Properties> /// /// The numeric value is compatible with `ULineBreak` in ICU4C. #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "datagen", derive(databake::Bake))] #[cfg_attr(feature = "datagen", databake(path = icu_properties))] #[allow(clippy::exhaustive_structs)] // newtype #[repr(transparent)] #[zerovec::make_ule(LineBreakULE)] pub struct LineBreak(pub u8); #[allow(missing_docs)] // These constants don't need individual documentation. #[allow(non_upper_case_globals)] impl LineBreak { pub const Unknown: LineBreak = LineBreak(0); // name="XX" pub const Ambiguous: LineBreak = LineBreak(1); // name="AI" pub const Alphabetic: LineBreak = LineBreak(2); // name="AL" pub const BreakBoth: LineBreak = LineBreak(3); // name="B2" pub const BreakAfter: LineBreak = LineBreak(4); // name="BA" pub const BreakBefore: LineBreak = LineBreak(5); // name="BB" pub const MandatoryBreak: LineBreak = LineBreak(6); // name="BK" pub const ContingentBreak: LineBreak = LineBreak(7); // name="CB" pub const ClosePunctuation: LineBreak = LineBreak(8); // name="CL" pub const CombiningMark: LineBreak = LineBreak(9); // name="CM" pub const CarriageReturn: LineBreak = LineBreak(10); // name="CR" pub const Exclamation: LineBreak = LineBreak(11); // name="EX" pub const Glue: LineBreak = LineBreak(12); // name="GL" pub const Hyphen: LineBreak = LineBreak(13); // name="HY" pub const Ideographic: LineBreak = LineBreak(14); // name="ID" pub const Inseparable: LineBreak = LineBreak(15); // name="IN" pub const InfixNumeric: LineBreak = LineBreak(16); // name="IS" pub const LineFeed: LineBreak = LineBreak(17); // name="LF" pub const Nonstarter: LineBreak = LineBreak(18); // name="NS" pub const Numeric: LineBreak = LineBreak(19); // name="NU" pub const OpenPunctuation: LineBreak = LineBreak(20); // name="OP" pub const PostfixNumeric: LineBreak = LineBreak(21); // name="PO" pub const PrefixNumeric: LineBreak = LineBreak(22); // name="PR" pub const Quotation: LineBreak = LineBreak(23); // name="QU" pub const ComplexContext: LineBreak = LineBreak(24); // name="SA" pub const Surrogate: LineBreak = LineBreak(25); // name="SG" pub const Space: LineBreak = LineBreak(26); // name="SP" pub const BreakSymbols: LineBreak = LineBreak(27); // name="SY" pub const ZWSpace: LineBreak = LineBreak(28); // name="ZW" pub const NextLine: LineBreak = LineBreak(29); // name="NL" pub const WordJoiner: LineBreak = LineBreak(30); // name="WJ" pub const H2: LineBreak = LineBreak(31); // name="H2" pub const H3: LineBreak = LineBreak(32); // name="H3" pub const JL: LineBreak = LineBreak(33); // name="JL" pub const JT: LineBreak = LineBreak(34); // name="JT" pub const JV: LineBreak = LineBreak(35); // name="JV" pub const CloseParenthesis: LineBreak = LineBreak(36); // name="CP" pub const ConditionalJapaneseStarter: LineBreak = LineBreak(37); // name="CJ" pub const HebrewLetter: LineBreak = LineBreak(38); // name="HL" pub const RegionalIndicator: LineBreak = LineBreak(39); // name="RI" pub const EBase: LineBreak = LineBreak(40); // name="EB" pub const EModifier: LineBreak = LineBreak(41); // name="EM" pub const ZWJ: LineBreak = LineBreak(42); // name="ZWJ" // Added in ICU 74: pub const Aksara: LineBreak = LineBreak(43); // name="AK" pub const AksaraPrebase: LineBreak = LineBreak(44); // name=AP" pub const AksaraStart: LineBreak = LineBreak(45); // name=AS" pub const ViramaFinal: LineBreak = LineBreak(46); // name=VF" pub const Virama: LineBreak = LineBreak(47); // name=VI" } impl_value_getter! { markers: LineBreakNameToValueV1Marker / SINGLETON_PROPNAMES_FROM_LB_V1, LineBreakVal impl LineBreak { /// Return a [`PropertyValueNameToEnumMapper`], capable of looking up values /// from strings for the `Line_Break` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::LineBreak; /// /// let lookup = LineBreak::name_to_enum_mapper(); /// // short name for value /// assert_eq!(lookup.get_strict("BK"), Some(LineBreak::MandatoryBreak)); /// assert_eq!(lookup.get_strict("AL"), Some(LineBreak::Alphabetic)); /// // long name for value /// assert_eq!(lookup.get_strict("Mandatory_Break"), Some(LineBreak::MandatoryBrea /// assert_eq!(lookup.get_strict("Alphabetic"), Some(LineBreak::Alphabetic)); /// // name has incorrect casing and dash instead of underscore /// assert_eq!(lookup.get_strict("mandatory-Break"), None); /// // loose matching of name /// assert_eq!(lookup.get_loose("mandatory-Break"), Some(LineBreak::MandatoryBreak /// // fake property /// assert_eq!(lookup.get_strict("Stochastic_Break"), None); /// ``` pub fn get_name_to_enum_mapper() / name_to_enum_mapper(); /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up short names /// for values of the `Line_Break` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::LineBreak; /// /// let lookup = LineBreak::enum_to_short_name_mapper(); /// assert_eq!(lookup.get(LineBreak::MandatoryBreak), Some("BK")); /// assert_eq!(lookup.get(LineBreak::Alphabetic), Some("AL")); /// ``` pub fn get_enum_to_short_name_mapper() / enum_to_short_name_mapper() -> PropertyEnumToV /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up long names /// for values of the `Line_Break` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::LineBreak; /// /// let lookup = LineBreak::enum_to_long_name_mapper(); /// assert_eq!(lookup.get(LineBreak::MandatoryBreak), Some("Mandatory_Break")); /// assert_eq!(lookup.get(LineBreak::Alphabetic), Some("Alphabetic")); /// ``` pub fn get_enum_to_long_name_mapper() / enum_to_long_name_mapper() -> PropertyEnumToVal } } /// Enumerated property Grapheme_Cluster_Break. /// /// See "Default Grapheme Cluster Boundary Specification" in UAX #29 for the /// summary of each property value: /// <https://www.unicode.org/reports/tr29/#Default_Grapheme_Cluster_Table> /// /// The numeric value is compatible with `UGraphemeClusterBreak` in ICU4C. #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "datagen", derive(databake::Bake))] #[cfg_attr(feature = "datagen", databake(path = icu_properties))] #[allow(clippy::exhaustive_structs)] // this type is stable #[repr(transparent)] #[zerovec::make_ule(GraphemeClusterBreakULE)] pub struct GraphemeClusterBreak(pub u8); #[allow(missing_docs)] // These constants don't need individual documentation. #[allow(non_upper_case_globals)] impl GraphemeClusterBreak { pub const Other: GraphemeClusterBreak = GraphemeClusterBreak(0); // name="XX" pub const Control: GraphemeClusterBreak = GraphemeClusterBreak(1); // name="CN" pub const CR: GraphemeClusterBreak = GraphemeClusterBreak(2); // name="CR" pub const Extend: GraphemeClusterBreak = GraphemeClusterBreak(3); // name="EX" pub const L: GraphemeClusterBreak = GraphemeClusterBreak(4); // name="L" pub const LF: GraphemeClusterBreak = GraphemeClusterBreak(5); // name="LF" pub const LV: GraphemeClusterBreak = GraphemeClusterBreak(6); // name="LV" pub const LVT: GraphemeClusterBreak = GraphemeClusterBreak(7); // name="LVT" pub const T: GraphemeClusterBreak = GraphemeClusterBreak(8); // name="T" pub const V: GraphemeClusterBreak = GraphemeClusterBreak(9); // name="V" pub const SpacingMark: GraphemeClusterBreak = GraphemeClusterBreak(10); // name="SM" pub const Prepend: GraphemeClusterBreak = GraphemeClusterBreak(11); // name="PP" pub const RegionalIndicator: GraphemeClusterBreak = GraphemeClusterBreak(12); // name=" /// This value is obsolete and unused. pub const EBase: GraphemeClusterBreak = GraphemeClusterBreak(13); // name="EB" /// This value is obsolete and unused. pub const EBaseGAZ: GraphemeClusterBreak = GraphemeClusterBreak(14); // name="EBG" /// This value is obsolete and unused. pub const EModifier: GraphemeClusterBreak = GraphemeClusterBreak(15); // name="EM" /// This value is obsolete and unused. pub const GlueAfterZwj: GraphemeClusterBreak = GraphemeClusterBreak(16); // name="GAZ" pub const ZWJ: GraphemeClusterBreak = GraphemeClusterBreak(17); // name="ZWJ" } impl_value_getter! { markers: GraphemeClusterBreakNameToValueV1Marker / SINGLETON_PROPNAMES_FROM_GCB_V1, impl GraphemeClusterBreak { /// Return a [`PropertyValueNameToEnumMapper`], capable of looking up values /// from strings for the `Grapheme_Cluster_Break` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::GraphemeClusterBreak; /// /// let lookup = GraphemeClusterBreak::name_to_enum_mapper(); /// // short name for value /// assert_eq!(lookup.get_strict("EX"), Some(GraphemeClusterBreak::Extend)); /// assert_eq!(lookup.get_strict("RI"), Some(GraphemeClusterBreak::RegionalIndicat /// // long name for value /// assert_eq!(lookup.get_strict("Extend"), Some(GraphemeClusterBreak::Extend)); /// assert_eq!(lookup.get_strict("Regional_Indicator"), Some(GraphemeClusterBreak: /// // name has incorrect casing and lacks an underscore /// assert_eq!(lookup.get_strict("regionalindicator"), None); /// // loose matching of name /// assert_eq!(lookup.get_loose("regionalindicator"), Some(GraphemeClusterBreak::R /// // fake property /// assert_eq!(lookup.get_strict("Regional_Indicator_Two_Point_Oh"), None); /// ``` pub fn get_name_to_enum_mapper() / name_to_enum_mapper(); /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up short names /// for values of the `Grapheme_Cluster_Break` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::GraphemeClusterBreak; /// /// let lookup = GraphemeClusterBreak::enum_to_short_name_mapper(); /// assert_eq!(lookup.get(GraphemeClusterBreak::Extend), Some("EX")); /// assert_eq!(lookup.get(GraphemeClusterBreak::RegionalIndicator), Some("RI")); /// ``` pub fn get_enum_to_short_name_mapper() / enum_to_short_name_mapper() -> PropertyEnumToV /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up long names /// for values of the `Grapheme_Cluster_Break` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::GraphemeClusterBreak; /// /// let lookup = GraphemeClusterBreak::enum_to_long_name_mapper(); /// assert_eq!(lookup.get(GraphemeClusterBreak::Extend), Some("Extend")); /// assert_eq!(lookup.get(GraphemeClusterBreak::RegionalIndicator), Some("Regional /// ``` pub fn get_enum_to_long_name_mapper() / enum_to_long_name_mapper() -> PropertyEnumToVal } } /// Enumerated property Word_Break. /// /// See "Default Word Boundary Specification" in UAX #29 for the summary of /// each property value: /// <https://www.unicode.org/reports/tr29/#Default_Word_Boundaries>. /// /// The numeric value is compatible with `UWordBreakValues` in ICU4C. #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "datagen", derive(databake::Bake))] #[cfg_attr(feature = "datagen", databake(path = icu_properties))] #[allow(clippy::exhaustive_structs)] // newtype #[repr(transparent)] #[zerovec::make_ule(WordBreakULE)] pub struct WordBreak(pub u8); create_const_array! { #[allow(missing_docs)] // These constants don't need individual documentation. #[allow(non_upper_case_globals)] impl WordBreak { pub const Other: WordBreak = WordBreak(0); // name="XX" pub const ALetter: WordBreak = WordBreak(1); // name="LE" pub const Format: WordBreak = WordBreak(2); // name="FO" pub const Katakana: WordBreak = WordBreak(3); // name="KA" pub const MidLetter: WordBreak = WordBreak(4); // name="ML" pub const MidNum: WordBreak = WordBreak(5); // name="MN" pub const Numeric: WordBreak = WordBreak(6); // name="NU" pub const ExtendNumLet: WordBreak = WordBreak(7); // name="EX" pub const CR: WordBreak = WordBreak(8); // name="CR" pub const Extend: WordBreak = WordBreak(9); // name="Extend" pub const LF: WordBreak = WordBreak(10); // name="LF" pub const MidNumLet: WordBreak = WordBreak(11); // name="MB" pub const Newline: WordBreak = WordBreak(12); // name="NL" pub const RegionalIndicator: WordBreak = WordBreak(13); // name="RI" pub const HebrewLetter: WordBreak = WordBreak(14); // name="HL" pub const SingleQuote: WordBreak = WordBreak(15); // name="SQ" pub const DoubleQuote: WordBreak = WordBreak(16); // name=DQ /// This value is obsolete and unused. pub const EBase: WordBreak = WordBreak(17); // name="EB" /// This value is obsolete and unused. pub const EBaseGAZ: WordBreak = WordBreak(18); // name="EBG" /// This value is obsolete and unused. pub const EModifier: WordBreak = WordBreak(19); // name="EM" /// This value is obsolete and unused. pub const GlueAfterZwj: WordBreak = WordBreak(20); // name="GAZ" pub const ZWJ: WordBreak = WordBreak(21); // name="ZWJ" pub const WSegSpace: WordBreak = WordBreak(22); // name="WSegSpace" } } impl_value_getter! { markers: WordBreakNameToValueV1Marker / SINGLETON_PROPNAMES_FROM_WB_V1, WordBreakVal impl WordBreak { /// Return a [`PropertyValueNameToEnumMapper`], capable of looking up values /// from strings for the `Word_Break` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::WordBreak; /// /// let lookup = WordBreak::name_to_enum_mapper(); /// // short name for value /// assert_eq!(lookup.get_strict("KA"), Some(WordBreak::Katakana)); /// assert_eq!(lookup.get_strict("LE"), Some(WordBreak::ALetter)); /// // long name for value /// assert_eq!(lookup.get_strict("Katakana"), Some(WordBreak::Katakana)); /// assert_eq!(lookup.get_strict("ALetter"), Some(WordBreak::ALetter)); /// // name has incorrect casing /// assert_eq!(lookup.get_strict("Aletter"), None); /// // loose matching of name /// assert_eq!(lookup.get_loose("Aletter"), Some(WordBreak::ALetter)); /// assert_eq!(lookup.get_loose("w_seg_space"), Some(WordBreak::WSegSpace)); /// // fake property /// assert_eq!(lookup.get_strict("Quadruple_Quote"), None); /// ``` pub fn get_name_to_enum_mapper() / name_to_enum_mapper(); /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up short names /// for values of the `Word_Break` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::WordBreak; /// /// let lookup = WordBreak::enum_to_short_name_mapper(); /// assert_eq!(lookup.get(WordBreak::Katakana), Some("KA")); /// assert_eq!(lookup.get(WordBreak::ALetter), Some("LE")); /// assert_eq!(lookup.get(WordBreak::WSegSpace), Some("WSegSpace")); /// ``` pub fn get_enum_to_short_name_mapper() / enum_to_short_name_mapper() -> PropertyEnumToV /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up long names /// for values of the `Word_Break` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::WordBreak; /// /// let lookup = WordBreak::enum_to_long_name_mapper(); /// assert_eq!(lookup.get(WordBreak::Katakana), Some("Katakana")); /// assert_eq!(lookup.get(WordBreak::ALetter), Some("ALetter")); /// assert_eq!(lookup.get(WordBreak::WSegSpace), Some("WSegSpace")); /// ``` pub fn get_enum_to_long_name_mapper() / enum_to_long_name_mapper() -> PropertyEnumToVal } } /// Enumerated property Sentence_Break. /// See "Default Sentence Boundary Specification" in UAX #29 for the summary of /// each property value: /// <https://www.unicode.org/reports/tr29/#Default_Word_Boundaries>. /// /// The numeric value is compatible with `USentenceBreak` in ICU4C. #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "datagen", derive(databake::Bake))] #[cfg_attr(feature = "datagen", databake(path = icu_properties))] #[allow(clippy::exhaustive_structs)] // newtype #[repr(transparent)] #[zerovec::make_ule(SentenceBreakULE)] pub struct SentenceBreak(pub u8); create_const_array! { #[allow(missing_docs)] // These constants don't need individual documentation. #[allow(non_upper_case_globals)] impl SentenceBreak { pub const Other: SentenceBreak = SentenceBreak(0); // name="XX" pub const ATerm: SentenceBreak = SentenceBreak(1); // name="AT" pub const Close: SentenceBreak = SentenceBreak(2); // name="CL" pub const Format: SentenceBreak = SentenceBreak(3); // name="FO" pub const Lower: SentenceBreak = SentenceBreak(4); // name="LO" pub const Numeric: SentenceBreak = SentenceBreak(5); // name="NU" pub const OLetter: SentenceBreak = SentenceBreak(6); // name="LE" pub const Sep: SentenceBreak = SentenceBreak(7); // name="SE" pub const Sp: SentenceBreak = SentenceBreak(8); // name="SP" pub const STerm: SentenceBreak = SentenceBreak(9); // name="ST" pub const Upper: SentenceBreak = SentenceBreak(10); // name="UP" pub const CR: SentenceBreak = SentenceBreak(11); // name="CR" pub const Extend: SentenceBreak = SentenceBreak(12); // name="EX" pub const LF: SentenceBreak = SentenceBreak(13); // name="LF" pub const SContinue: SentenceBreak = SentenceBreak(14); // name="SC" } } impl_value_getter! { markers: SentenceBreakNameToValueV1Marker / SINGLETON_PROPNAMES_FROM_SB_V1, Sentence impl SentenceBreak { /// Return a [`PropertyValueNameToEnumMapper`], capable of looking up values /// from strings for the `Sentence_Break` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::SentenceBreak; /// /// let lookup = SentenceBreak::name_to_enum_mapper(); /// // short name for value /// assert_eq!(lookup.get_strict("FO"), Some(SentenceBreak::Format)); /// assert_eq!(lookup.get_strict("NU"), Some(SentenceBreak::Numeric)); /// // long name for value /// assert_eq!(lookup.get_strict("Format"), Some(SentenceBreak::Format)); /// assert_eq!(lookup.get_strict("Numeric"), Some(SentenceBreak::Numeric)); /// // name has incorrect casing /// assert_eq!(lookup.get_strict("fOrmat"), None); /// // loose matching of name /// assert_eq!(lookup.get_loose("fOrmat"), Some(SentenceBreak::Format)); /// // fake property /// assert_eq!(lookup.get_strict("Fixer_Upper"), None); /// ``` pub fn get_name_to_enum_mapper() / name_to_enum_mapper(); /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up short names /// for values of the `Sentence_Break` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::SentenceBreak; /// /// let lookup = SentenceBreak::enum_to_short_name_mapper(); /// assert_eq!(lookup.get(SentenceBreak::Format), Some("FO")); /// assert_eq!(lookup.get(SentenceBreak::Numeric), Some("NU")); /// ``` pub fn get_enum_to_short_name_mapper() / enum_to_short_name_mapper() -> PropertyEnumToV /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up long names /// for values of the `Sentence_Break` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::SentenceBreak; /// /// let lookup = SentenceBreak::enum_to_long_name_mapper(); /// assert_eq!(lookup.get(SentenceBreak::Format), Some("Format")); /// assert_eq!(lookup.get(SentenceBreak::Numeric), Some("Numeric")); /// assert_eq!(lookup.get(SentenceBreak::SContinue), Some("SContinue")); /// ``` pub fn get_enum_to_long_name_mapper() / enum_to_long_name_mapper() -> PropertyEnumToVal } } /// Property Canonical_Combining_Class. /// See UAX #15: /// <https://www.unicode.org/reports/tr15/>. /// /// See `icu::normalizer::properties::CanonicalCombiningClassMap` for the API /// to look up the Canonical_Combining_Class property by scalar value. // // NOTE: The Pernosco debugger has special knowledge // of this struct. Please do not change the bit layout // or the crate-module-qualified name of this struct // without coordination. #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "datagen", derive(databake::Bake))] #[cfg_attr(feature = "datagen", databake(path = icu_properties))] #[allow(clippy::exhaustive_structs)] // newtype #[repr(transparent)] #[zerovec::make_ule(CanonicalCombiningClassULE)] pub struct CanonicalCombiningClass(pub u8); create_const_array! { // These constant names come from PropertyValueAliases.txt #[allow(missing_docs)] // These constants don't need individual documentation. #[allow(non_upper_case_globals)] impl CanonicalCombiningClass { pub const NotReordered: CanonicalCombiningClass = CanonicalCombiningClass(0); // name=" pub const Overlay: CanonicalCombiningClass = CanonicalCombiningClass(1); // name="OV" pub const HanReading: CanonicalCombiningClass = CanonicalCombiningClass(6); // name="HA pub const Nukta: CanonicalCombiningClass = CanonicalCombiningClass(7); // name="NK" pub const KanaVoicing: CanonicalCombiningClass = CanonicalCombiningClass(8); // name="K pub const Virama: CanonicalCombiningClass = CanonicalCombiningClass(9); // name="VR" pub const CCC10: CanonicalCombiningClass = CanonicalCombiningClass(10); // name="CCC10" pub const CCC11: CanonicalCombiningClass = CanonicalCombiningClass(11); // name="CCC11" pub const CCC12: CanonicalCombiningClass = CanonicalCombiningClass(12); // name="CCC12" pub const CCC13: CanonicalCombiningClass = CanonicalCombiningClass(13); // name="CCC13" pub const CCC14: CanonicalCombiningClass = CanonicalCombiningClass(14); // name="CCC14" pub const CCC15: CanonicalCombiningClass = CanonicalCombiningClass(15); // name="CCC15" pub const CCC16: CanonicalCombiningClass = CanonicalCombiningClass(16); // name="CCC16" pub const CCC17: CanonicalCombiningClass = CanonicalCombiningClass(17); // name="CCC17" pub const CCC18: CanonicalCombiningClass = CanonicalCombiningClass(18); // name="CCC18" pub const CCC19: CanonicalCombiningClass = CanonicalCombiningClass(19); // name="CCC19" pub const CCC20: CanonicalCombiningClass = CanonicalCombiningClass(20); // name="CCC20" pub const CCC21: CanonicalCombiningClass = CanonicalCombiningClass(21); // name="CCC21" pub const CCC22: CanonicalCombiningClass = CanonicalCombiningClass(22); // name="CCC22" pub const CCC23: CanonicalCombiningClass = CanonicalCombiningClass(23); // name="CCC23" pub const CCC24: CanonicalCombiningClass = CanonicalCombiningClass(24); // name="CCC24" pub const CCC25: CanonicalCombiningClass = CanonicalCombiningClass(25); // name="CCC25" pub const CCC26: CanonicalCombiningClass = CanonicalCombiningClass(26); // name="CCC26" pub const CCC27: CanonicalCombiningClass = CanonicalCombiningClass(27); // name="CCC27" pub const CCC28: CanonicalCombiningClass = CanonicalCombiningClass(28); // name="CCC28" pub const CCC29: CanonicalCombiningClass = CanonicalCombiningClass(29); // name="CCC29" pub const CCC30: CanonicalCombiningClass = CanonicalCombiningClass(30); // name="CCC30" pub const CCC31: CanonicalCombiningClass = CanonicalCombiningClass(31); // name="CCC31" pub const CCC32: CanonicalCombiningClass = CanonicalCombiningClass(32); // name="CCC32" pub const CCC33: CanonicalCombiningClass = CanonicalCombiningClass(33); // name="CCC33" pub const CCC34: CanonicalCombiningClass = CanonicalCombiningClass(34); // name="CCC34" pub const CCC35: CanonicalCombiningClass = CanonicalCombiningClass(35); // name="CCC35" pub const CCC36: CanonicalCombiningClass = CanonicalCombiningClass(36); // name="CCC36" pub const CCC84: CanonicalCombiningClass = CanonicalCombiningClass(84); // name="CCC84" pub const CCC91: CanonicalCombiningClass = CanonicalCombiningClass(91); // name="CCC91" pub const CCC103: CanonicalCombiningClass = CanonicalCombiningClass(103); // name="CCC1 pub const CCC107: CanonicalCombiningClass = CanonicalCombiningClass(107); // name="CCC1 pub const CCC118: CanonicalCombiningClass = CanonicalCombiningClass(118); // name="CCC1 pub const CCC122: CanonicalCombiningClass = CanonicalCombiningClass(122); // name="CCC1 pub const CCC129: CanonicalCombiningClass = CanonicalCombiningClass(129); // name="CCC1 pub const CCC130: CanonicalCombiningClass = CanonicalCombiningClass(130); // name="CCC1 pub const CCC132: CanonicalCombiningClass = CanonicalCombiningClass(132); // name="CCC1 pub const CCC133: CanonicalCombiningClass = CanonicalCombiningClass(133); // name="CCC1 pub const AttachedBelowLeft: CanonicalCombiningClass = CanonicalCombiningClass(200); / pub const AttachedBelow: CanonicalCombiningClass = CanonicalCombiningClass(202); // nam pub const AttachedAbove: CanonicalCombiningClass = CanonicalCombiningClass(214); // nam pub const AttachedAboveRight: CanonicalCombiningClass = CanonicalCombiningClass(216); pub const BelowLeft: CanonicalCombiningClass = CanonicalCombiningClass(218); // name="B pub const Below: CanonicalCombiningClass = CanonicalCombiningClass(220); // name="B" pub const BelowRight: CanonicalCombiningClass = CanonicalCombiningClass(222); // name=" pub const Left: CanonicalCombiningClass = CanonicalCombiningClass(224); // name="L" pub const Right: CanonicalCombiningClass = CanonicalCombiningClass(226); // name="R" pub const AboveLeft: CanonicalCombiningClass = CanonicalCombiningClass(228); // name="A pub const Above: CanonicalCombiningClass = CanonicalCombiningClass(230); // name="A" pub const AboveRight: CanonicalCombiningClass = CanonicalCombiningClass(232); // name=" pub const DoubleBelow: CanonicalCombiningClass = CanonicalCombiningClass(233); // name= pub const DoubleAbove: CanonicalCombiningClass = CanonicalCombiningClass(234); // name= pub const IotaSubscript: CanonicalCombiningClass = CanonicalCombiningClass(240); // nam } } impl_value_getter! { markers: CanonicalCombiningClassNameToValueV1Marker / SINGLETON_PROPNAMES_FROM_CCC_ impl CanonicalCombiningClass { /// Return a [`PropertyValueNameToEnumMapper`], capable of looking up values /// from strings for the `Canonical_Combining_Class` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::CanonicalCombiningClass; /// /// let lookup = CanonicalCombiningClass::name_to_enum_mapper(); /// // short name for value /// assert_eq!(lookup.get_strict("AL"), Some(CanonicalCombiningClass::AboveLeft)); /// assert_eq!(lookup.get_strict("ATBL"), Some(CanonicalCombiningClass::AttachedBe /// assert_eq!(lookup.get_strict("CCC10"), Some(CanonicalCombiningClass::CCC10)); /// // long name for value /// assert_eq!(lookup.get_strict("Above_Left"), Some(CanonicalCombiningClass::Abov /// assert_eq!(lookup.get_strict("Attached_Below_Left"), Some(CanonicalCombiningCl /// // name has incorrect casing and hyphens /// assert_eq!(lookup.get_strict("attached-below-left"), None); /// // loose matching of name /// assert_eq!(lookup.get_loose("attached-below-left"), Some(CanonicalCombiningCla /// // fake property /// assert_eq!(lookup.get_strict("Linear_Z"), None); /// ``` pub fn get_name_to_enum_mapper() / name_to_enum_mapper(); /// Return a [`PropertyEnumToValueNameSparseMapper`], capable of looking up short names /// for values of the `Canonical_Combining_Class` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::CanonicalCombiningClass; /// /// let lookup = CanonicalCombiningClass::enum_to_short_name_mapper(); /// assert_eq!(lookup.get(CanonicalCombiningClass::AboveLeft), Some("AL")); /// assert_eq!(lookup.get(CanonicalCombiningClass::AttachedBelowLeft), Some("ATBL" /// assert_eq!(lookup.get(CanonicalCombiningClass::CCC10), Some("CCC10")); /// ``` pub fn get_enum_to_short_name_mapper() / enum_to_short_name_mapper() -> PropertyEnumToV /// Return a [`PropertyEnumToValueNameSparseMapper`], capable of looking up long names /// for values of the `Canonical_Combining_Class` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::CanonicalCombiningClass; /// /// let lookup = CanonicalCombiningClass::enum_to_long_name_mapper(); /// assert_eq!(lookup.get(CanonicalCombiningClass::AboveLeft), Some("Above_Left")) /// assert_eq!(lookup.get(CanonicalCombiningClass::AttachedBelowLeft), Some("Attac /// assert_eq!(lookup.get(CanonicalCombiningClass::CCC10), Some("CCC10")); /// ``` pub fn get_enum_to_long_name_mapper() / enum_to_long_name_mapper() -> PropertyEnumToVal } } /// Property Indic_Syllabic_Category. /// See UAX #44: /// <https://www.unicode.org/reports/tr44/#Indic_Syllabic_Category>. /// /// The numeric value is compatible with `UIndicSyllabicCategory` in ICU4C. #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "datagen", derive(databake::Bake))] #[cfg_attr(feature = "datagen", databake(path = icu_properties))] #[allow(clippy::exhaustive_structs)] // newtype #[repr(transparent)] #[zerovec::make_ule(IndicSyllabicCategoryULE)] pub struct IndicSyllabicCategory(pub u8); create_const_array! { #[allow(missing_docs)] // These constants don't need individual documentation. #[allow(non_upper_case_globals)] impl IndicSyllabicCategory { pub const Other: IndicSyllabicCategory = IndicSyllabicCategory(0); pub const Avagraha: IndicSyllabicCategory = IndicSyllabicCategory(1); pub const Bindu: IndicSyllabicCategory = IndicSyllabicCategory(2); pub const BrahmiJoiningNumber: IndicSyllabicCategory = IndicSyllabicCategory(3); pub const CantillationMark: IndicSyllabicCategory = IndicSyllabicCategory(4); pub const Consonant: IndicSyllabicCategory = IndicSyllabicCategory(5); pub const ConsonantDead: IndicSyllabicCategory = IndicSyllabicCategory(6); pub const ConsonantFinal: IndicSyllabicCategory = IndicSyllabicCategory(7); pub const ConsonantHeadLetter: IndicSyllabicCategory = IndicSyllabicCategory(8); pub const ConsonantInitialPostfixed: IndicSyllabicCategory = IndicSyllabicCategory(9) pub const ConsonantKiller: IndicSyllabicCategory = IndicSyllabicCategory(10); pub const ConsonantMedial: IndicSyllabicCategory = IndicSyllabicCategory(11); pub const ConsonantPlaceholder: IndicSyllabicCategory = IndicSyllabicCategory(12); pub const ConsonantPrecedingRepha: IndicSyllabicCategory = IndicSyllabicCategory(13); pub const ConsonantPrefixed: IndicSyllabicCategory = IndicSyllabicCategory(14); pub const ConsonantSucceedingRepha: IndicSyllabicCategory = IndicSyllabicCategory(15) pub const ConsonantSubjoined: IndicSyllabicCategory = IndicSyllabicCategory(16); pub const ConsonantWithStacker: IndicSyllabicCategory = IndicSyllabicCategory(17); pub const GeminationMark: IndicSyllabicCategory = IndicSyllabicCategory(18); pub const InvisibleStacker: IndicSyllabicCategory = IndicSyllabicCategory(19); pub const Joiner: IndicSyllabicCategory = IndicSyllabicCategory(20); pub const ModifyingLetter: IndicSyllabicCategory = IndicSyllabicCategory(21); pub const NonJoiner: IndicSyllabicCategory = IndicSyllabicCategory(22); pub const Nukta: IndicSyllabicCategory = IndicSyllabicCategory(23); pub const Number: IndicSyllabicCategory = IndicSyllabicCategory(24); pub const NumberJoiner: IndicSyllabicCategory = IndicSyllabicCategory(25); pub const PureKiller: IndicSyllabicCategory = IndicSyllabicCategory(26); pub const RegisterShifter: IndicSyllabicCategory = IndicSyllabicCategory(27); pub const SyllableModifier: IndicSyllabicCategory = IndicSyllabicCategory(28); pub const ToneLetter: IndicSyllabicCategory = IndicSyllabicCategory(29); pub const ToneMark: IndicSyllabicCategory = IndicSyllabicCategory(30); pub const Virama: IndicSyllabicCategory = IndicSyllabicCategory(31); pub const Visarga: IndicSyllabicCategory = IndicSyllabicCategory(32); pub const Vowel: IndicSyllabicCategory = IndicSyllabicCategory(33); pub const VowelDependent: IndicSyllabicCategory = IndicSyllabicCategory(34); pub const VowelIndependent: IndicSyllabicCategory = IndicSyllabicCategory(35); } } impl_value_getter! { markers: IndicSyllabicCategoryNameToValueV1Marker / SINGLETON_PROPNAMES_FROM_INSC_V impl IndicSyllabicCategory { /// Return a [`PropertyValueNameToEnumMapper`], capable of looking up values /// from strings for the `Indic_Syllabic_Category` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::IndicSyllabicCategory; /// /// let lookup = IndicSyllabicCategory::name_to_enum_mapper(); /// // long/short name for value /// assert_eq!(lookup.get_strict("Brahmi_Joining_Number"), Some(IndicSyllabicCateg /// assert_eq!(lookup.get_strict("Vowel_Independent"), Some(IndicSyllabicCategory: /// // name has incorrect casing and hyphens /// assert_eq!(lookup.get_strict("brahmi-joining-number"), None); /// // loose matching of name /// assert_eq!(lookup.get_loose("brahmi-joining-number"), Some(IndicSyllabicCatego /// // fake property /// assert_eq!(lookup.get_strict("Tone_Number"), None); /// ``` pub fn get_name_to_enum_mapper() / name_to_enum_mapper(); /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up short names /// for values of the `Indic_Syllabic_Category` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::IndicSyllabicCategory; /// /// let lookup = IndicSyllabicCategory::enum_to_short_name_mapper(); /// assert_eq!(lookup.get(IndicSyllabicCategory::BrahmiJoiningNumber), Some("Brahm /// assert_eq!(lookup.get(IndicSyllabicCategory::VowelIndependent), Some("Vowel_In /// ``` pub fn get_enum_to_short_name_mapper() / enum_to_short_name_mapper() -> PropertyEnumToV /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up long names /// for values of the `Indic_Syllabic_Category` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::IndicSyllabicCategory; /// /// let lookup = IndicSyllabicCategory::enum_to_long_name_mapper(); /// assert_eq!(lookup.get(IndicSyllabicCategory::BrahmiJoiningNumber), Some("Brahm /// assert_eq!(lookup.get(IndicSyllabicCategory::VowelIndependent), Some("Vowel_In /// ``` pub fn get_enum_to_long_name_mapper() / enum_to_long_name_mapper() -> PropertyEnumToVal } } /// Enumerated property Joining_Type. /// See Section 9.2, Arabic Cursive Joining in The Unicode Standard for the summary of /// each property value. /// /// The numeric value is compatible with `UJoiningType` in ICU4C. #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "datagen", derive(databake::Bake))] #[cfg_attr(feature = "datagen", databake(path = icu_properties))] #[allow(clippy::exhaustive_structs)] // newtype #[repr(transparent)] #[zerovec::make_ule(JoiningTypeULE)] pub struct JoiningType(pub u8); create_const_array! { #[allow(missing_docs)] // These constants don't need individual documentation. #[allow(non_upper_case_globals)] impl JoiningType { pub const NonJoining: JoiningType = JoiningType(0); // name="U" pub const JoinCausing: JoiningType = JoiningType(1); // name="C" pub const DualJoining: JoiningType = JoiningType(2); // name="D" pub const LeftJoining: JoiningType = JoiningType(3); // name="L" pub const RightJoining: JoiningType = JoiningType(4); // name="R" pub const Transparent: JoiningType = JoiningType(5); // name="T" } } impl_value_getter! { markers: JoiningTypeNameToValueV1Marker / SINGLETON_PROPNAMES_FROM_JT_V1, JoiningTyp impl JoiningType { /// Return a [`PropertyValueNameToEnumMapper`], capable of looking up values /// from strings for the `Joining_Type` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::JoiningType; /// /// let lookup = JoiningType::name_to_enum_mapper(); /// // short name for value /// assert_eq!(lookup.get_strict("T"), Some(JoiningType::Transparent)); /// assert_eq!(lookup.get_strict("D"), Some(JoiningType::DualJoining)); /// // long name for value /// assert_eq!(lookup.get_strict("Join_Causing"), Some(JoiningType::JoinCausing)); /// assert_eq!(lookup.get_strict("Non_Joining"), Some(JoiningType::NonJoining)); /// // name has incorrect casing /// assert_eq!(lookup.get_strict("LEFT_JOINING"), None); /// // loose matching of name /// assert_eq!(lookup.get_loose("LEFT_JOINING"), Some(JoiningType::LeftJoining)); /// // fake property /// assert_eq!(lookup.get_strict("Inner_Joining"), None); /// ``` pub fn get_name_to_enum_mapper() / name_to_enum_mapper(); /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up short names /// for values of the `Joining_Type` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::JoiningType; /// /// let lookup = JoiningType::enum_to_short_name_mapper(); /// assert_eq!(lookup.get(JoiningType::JoinCausing), Some("C")); /// assert_eq!(lookup.get(JoiningType::LeftJoining), Some("L")); /// ``` pub fn get_enum_to_short_name_mapper() / enum_to_short_name_mapper() -> PropertyEnumToV /// Return a [`PropertyEnumToValueNameLinearMapper`], capable of looking up long names /// for values of the `Joining_Type` enumerated property. /// /// ✨ *Enabled with the `compiled_data` Cargo feature.* /// /// [�� Help choosing a constructor](icu_provider::constructors) /// /// # Example /// /// ``` /// use icu::properties::JoiningType; /// /// let lookup = JoiningType::enum_to_long_name_mapper(); /// assert_eq!(lookup.get(JoiningType::Transparent), Some("Transparent")); /// assert_eq!(lookup.get(JoiningType::NonJoining), Some("Non_Joining")); /// assert_eq!(lookup.get(JoiningType::RightJoining), Some("Right_Joining")); /// ``` pub fn get_enum_to_long_name_mapper() / enum_to_long_name_mapper() -> PropertyEnumToVal } } #[cfg(test)] mod test_enumerated_property_completeness { use super::*; use alloc::collections::BTreeMap; fn check_enum<'a>( lookup: &PropertyValueNameToEnumMapV1<'static>, consts: impl IntoIterator<Item = &'a (&'static str, u16)>, ) { let mut data: BTreeMap<_, _> = lookup .map .iter_copied_values() .map(|(name, value)| { ( value, ( String::from_utf8(name.as_byte_slice().to_vec()).unwrap(), "Data", ), ) }) .collect(); let consts = consts .into_iter() .map(|(name, value)| (*value, (name.to_string(), "Consts"))); let mut diff = Vec::new(); for t @ (value, _) in consts { if data.remove(&value).is_none() { diff.push(t); } } diff.extend(data); let mut fmt_diff = String::new(); for (value, (name, source)) in diff { fmt_diff.push_str(&format!("{source}:\t{name} = {value:?}\n")); } assert!( fmt_diff.is_empty(), "Values defined in data do not match values defined in consts. Difference:\n{}", fmt_diff ); } #[test] fn test_ea() { check_enum( crate::provider::Baked::SINGLETON_PROPNAMES_FROM_EA_V1, EastAsianWidth::ALL_CONSTS, ); } #[test] fn test_ccc() { check_enum( crate::provider::Baked::SINGLETON_PROPNAMES_FROM_CCC_V1, CanonicalCombiningClass::ALL_CONSTS, ); } #[test] fn test_jt() { check_enum( crate::provider::Baked::SINGLETON_PROPNAMES_FROM_JT_V1, JoiningType::ALL_CONSTS, ); } #[test] fn test_insc() { check_enum( crate::provider::Baked::SINGLETON_PROPNAMES_FROM_INSC_V1, IndicSyllabicCategory::ALL_CONSTS, ); } #[test] fn test_sb() { check_enum( crate::provider::Baked::SINGLETON_PROPNAMES_FROM_SB_V1, SentenceBreak::ALL_CONSTS, ); } #[test] fn test_wb() { check_enum( crate::provider::Baked::SINGLETON_PROPNAMES_FROM_WB_V1, WordBreak::ALL_CONSTS, ); } #[test] fn test_bc() { check_enum( crate::provider::Baked::SINGLETON_PROPNAMES_FROM_BC_V1, BidiClass::ALL_CONSTS, ); } #[test] fn test_hst() { check_enum( crate::provider::Baked::SINGLETON_PROPNAMES_FROM_HST_V1, HangulSyllableType::ALL_CONSTS, ); } }
¤ Dauer der Verarbeitung: 0.91 Sekunden (vorverarbeitet am 2026-06-19) ¤*© Formatika GbR, Deutschland |
|
||||||||||||||
2026-07-09