Struct PropertyParserBorrowed 

pub struct PropertyParserBorrowed<'a, T> { /* private fields */ }

A borrowed wrapper around property value name-to-enum data, returned by PropertyParser::as_borrowed(). More efficient to query.

Implementations

impl<T: TrieValue> PropertyParserBorrowed<'_, T>

pub fn get_strict_u16(self, name: &str) -> Option<u16>

Get the property value as a u16, doing a strict search looking for names that match exactly

Example

use icu::properties::props::GeneralCategory;
use icu::properties::PropertyParser;

let lookup = PropertyParser::<GeneralCategory>::new();
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);

pub fn get_strict(self, name: &str) -> Option<T>

Get the property value as a T, doing a strict search looking for names that match exactly

Example

use icu::properties::props::GeneralCategory;
use icu::properties::PropertyParser;

let lookup = PropertyParser::<GeneralCategory>::new();
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);

pub fn get_loose_u16(self, name: &str) -> Option<u16>

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::props::GeneralCategory;
use icu::properties::PropertyParser;

let lookup = PropertyParser::<GeneralCategory>::new();
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)
);

pub fn get_loose(self, name: &str) -> Option<T>

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::props::GeneralCategory;
use icu::properties::PropertyParser;

let lookup = PropertyParser::<GeneralCategory>::new();
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)
);

impl<T: TrieValue> PropertyParserBorrowed<'static, T>

pub fn new() -> Self

where T: ParseableEnumeratedProperty,

Creates a new instance of PropertyParserBorrowed<T> using compiled data.

✨ Enabled with the compiled_data Cargo feature.

📚 Help choosing a constructor

pub const fn static_to_owned(self) -> PropertyParser<T>

Cheaply converts a PropertyParserBorrowed<'static> into a PropertyParser.

Note: Due to branching and indirection, using PropertyParser might inhibit some compile-time optimizations that are possible with PropertyParserBorrowed.

Trait Implementations

impl<T> Clone for PropertyParserBorrowed<'_, T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, T: Debug> Debug for PropertyParserBorrowed<'a, T>

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

Formats the value using the given formatter.

impl<T: ParseableEnumeratedProperty> Default for PropertyParserBorrowed<'static, T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Copy for PropertyParserBorrowed<'_, T>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes