Struct GeneralCategoryGroup 

pub struct GeneralCategoryGroup(/* private fields */);

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, Letter is the union of UppercaseLetter, LowercaseLetter, etc.

See UCharCategory and U_GET_GC_MASK in ICU4C.

Implementations

impl GeneralCategoryGroup

pub const UppercaseLetter: GeneralCategoryGroup

An uppercase letter

pub const Lu: GeneralCategoryGroup = Self::UppercaseLetter

pub const Ll: Self = Self::LowercaseLetter

A lowercase letter

pub const LowercaseLetter: GeneralCategoryGroup

pub const TitlecaseLetter: GeneralCategoryGroup

A digraphic letter, with first part uppercase

pub const Lt: Self = Self::TitlecaseLetter

pub const ModifierLetter: GeneralCategoryGroup

A modifier letter

pub const Lm: Self = Self::ModifierLetter

pub const OtherLetter: GeneralCategoryGroup

Other letters, including syllables and ideographs

pub const Lo: Self = Self::OtherLetter

pub const CasedLetter: GeneralCategoryGroup

The union of UppercaseLetter, LowercaseLetter, and TitlecaseLetter

pub const LC: Self = Self::CasedLetter

pub const Letter: GeneralCategoryGroup

The union of all letter categories

pub const L: Self = Self::Letter

pub const NonspacingMark: GeneralCategoryGroup

A nonspacing combining mark (zero advance width)

pub const Mn: Self = Self::NonspacingMark

pub const EnclosingMark: GeneralCategoryGroup

An enclosing combining mark

pub const Me: Self = Self::EnclosingMark

pub const SpacingMark: GeneralCategoryGroup

A spacing combining mark (positive advance width)

pub const Mc: Self = Self::SpacingMark

pub const Mark: GeneralCategoryGroup

The union of all mark categories

pub const M: Self = Self::Mark

pub const DecimalNumber: GeneralCategoryGroup

A decimal digit

pub const Nd: Self = Self::DecimalNumber

pub const LetterNumber: GeneralCategoryGroup

A letterlike numeric character

pub const Nl: Self = Self::LetterNumber

pub const OtherNumber: GeneralCategoryGroup

A numeric character of other type

pub const No: Self = Self::OtherNumber

pub const Number: GeneralCategoryGroup

The union of all number categories

pub const N: Self = Self::Number

pub const SpaceSeparator: GeneralCategoryGroup

A space character (of various non-zero widths)

pub const Zs: Self = Self::SpaceSeparator

pub const LineSeparator: GeneralCategoryGroup

U+2028 LINE SEPARATOR only

pub const Zl: Self = Self::LineSeparator

pub const ParagraphSeparator: GeneralCategoryGroup

U+2029 PARAGRAPH SEPARATOR only

pub const Zp: Self = Self::ParagraphSeparator

pub const Separator: GeneralCategoryGroup

The union of all separator categories

pub const Z: Self = Self::Separator

pub const Control: GeneralCategoryGroup

A C0 or C1 control code

pub const Cc: Self = Self::Control

pub const Format: GeneralCategoryGroup

A format control character

pub const Cf: Self = Self::Format

pub const PrivateUse: GeneralCategoryGroup

A private-use character

pub const Co: Self = Self::PrivateUse

pub const Surrogate: GeneralCategoryGroup

A surrogate code point

pub const Cs: Self = Self::Surrogate

pub const Unassigned: GeneralCategoryGroup

A reserved unassigned code point or a noncharacter

pub const Cn: Self = Self::Unassigned

pub const Other: GeneralCategoryGroup

The union of all control code, reserved, and unassigned categories

pub const C: Self = Self::Other

pub const DashPunctuation: GeneralCategoryGroup

A dash or hyphen punctuation mark

pub const Pd: Self = Self::DashPunctuation

pub const OpenPunctuation: GeneralCategoryGroup

An opening punctuation mark (of a pair)

pub const Ps: Self = Self::OpenPunctuation

pub const ClosePunctuation: GeneralCategoryGroup

A closing punctuation mark (of a pair)

pub const Pe: Self = Self::ClosePunctuation

pub const ConnectorPunctuation: GeneralCategoryGroup

A connecting punctuation mark, like a tie

pub const Pc: Self = Self::ConnectorPunctuation

pub const InitialPunctuation: GeneralCategoryGroup

An initial quotation mark

pub const Pi: Self = Self::InitialPunctuation

pub const FinalPunctuation: GeneralCategoryGroup

A final quotation mark

pub const Pf: Self = Self::FinalPunctuation

pub const OtherPunctuation: GeneralCategoryGroup

A punctuation mark of other type

pub const Po: Self = Self::OtherPunctuation

pub const Punctuation: GeneralCategoryGroup

The union of all punctuation categories

pub const P: Self = Self::Punctuation

pub const MathSymbol: GeneralCategoryGroup

A symbol of mathematical use

pub const Sm: Self = Self::MathSymbol

pub const CurrencySymbol: GeneralCategoryGroup

A currency sign

pub const Sc: Self = Self::CurrencySymbol

pub const ModifierSymbol: GeneralCategoryGroup

A non-letterlike modifier symbol

pub const Sk: Self = Self::ModifierSymbol

pub const OtherSymbol: GeneralCategoryGroup

A symbol of other type

pub const So: Self = Self::OtherSymbol

pub const Symbol: GeneralCategoryGroup

The union of all symbol categories

pub const S: Self = Self::Symbol

pub const fn contains(self, val: GeneralCategory) -> bool

Return whether the code point belongs in the provided multi-value category.

use icu::properties::CodePointMapData;
use icu::properties::props::{GeneralCategory, GeneralCategoryGroup};

let gc = CodePointMapData::<GeneralCategory>::new();

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.get('\u{0301}'), GeneralCategory::NonspacingMark);
assert!(GeneralCategoryGroup::Mark.contains(gc.get('\u{0301}')));
assert!(!GeneralCategoryGroup::Letter.contains(gc.get('\u{0301}')));

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.get('\u{E007F}'), GeneralCategory::Format);
assert!(GeneralCategoryGroup::Other.contains(gc.get('\u{E007F}')));
assert!(!GeneralCategoryGroup::Separator.contains(gc.get('\u{E007F}')));

pub const fn complement(self) -> Self

Produce a GeneralCategoryGroup that is the inverse of this one

Example

use icu::properties::props::{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 all() -> Self

Return the group representing all GeneralCategory values

Example

use icu::properties::props::{GeneralCategory, GeneralCategoryGroup};

let all = GeneralCategoryGroup::all();

assert!(all.contains(GeneralCategory::MathSymbol));
assert!(all.contains(GeneralCategory::OtherPunctuation));
assert!(all.contains(GeneralCategory::UppercaseLetter));

pub const fn empty() -> Self

Return the empty group

Example

use icu::properties::props::{GeneralCategory, GeneralCategoryGroup};

let empty = GeneralCategoryGroup::empty();

assert!(!empty.contains(GeneralCategory::MathSymbol));
assert!(!empty.contains(GeneralCategory::OtherPunctuation));
assert!(!empty.contains(GeneralCategory::UppercaseLetter));

pub const fn union(self, other: Self) -> Self

Take the union of two groups

Example

use icu::properties::props::{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 intersection(self, other: Self) -> Self

Take the intersection of two groups

Example

use icu::properties::props::{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));

Trait Implementations

impl AsULE for GeneralCategoryGroup

type ULE = RawBytesULE<2>

The ULE type corresponding to Self.

fn to_unaligned(self) -> Self::ULE

Converts from Self to Self::ULE.

fn from_unaligned(ule: Self::ULE) -> Self

Converts from Self::ULE to Self.

impl Clone for GeneralCategoryGroup

fn clone(&self) -> GeneralCategoryGroup

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for GeneralCategoryGroup

impl Debug for GeneralCategoryGroup

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for GeneralCategoryGroup

impl From<GeneralCategory> for GeneralCategoryGroup

fn from(subcategory: GeneralCategory) -> Self

Converts to this type from the input type.

impl From<GeneralCategoryGroup> for u32

fn from(group: GeneralCategoryGroup) -> Self

Converts to this type from the input type.

impl From<u32> for GeneralCategoryGroup

fn from(mask: u32) -> Self

Converts to this type from the input type.

impl ParseableEnumeratedProperty for GeneralCategoryGroup

impl PartialEq for GeneralCategoryGroup

fn eq(&self, other: &GeneralCategoryGroup) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for GeneralCategoryGroup

impl TrieValue for GeneralCategoryGroup

type TryFromU32Error = TryFromIntError

Last-resort fallback value to return if we cannot read data from the trie.

fn try_from_u32(i: u32) -> Result<Self, Self::TryFromU32Error>

A parsing function that is primarily motivated by deserialization contexts. When the serialization type width is smaller than 32 bits, then it is expected that the call site will widen the value to a u32 first.

fn to_u32(self) -> u32

A method for converting back to a u32 that can roundtrip through Self::try_from_u32(). The default implementation of this trait method panics in debug mode and returns 0 in release mode.