Struct CanonicalDecompositionBorrowed

struct CanonicalDecompositionBorrowed<'a> { ... }

Borrowed version of the raw (non-recursive) canonical decomposition operation.

Callers should generally use DecomposingNormalizer instead of this API. However, this API is provided for callers such as HarfBuzz that specifically want access to non-recursive canonical decomposition e.g. for use in a glyph-availability-guided custom normalizer.

Implementations

impl CanonicalDecompositionBorrowed<'_>

fn decompose(self: &Self, c: char) -> Decomposed

Performs non-recursive canonical decomposition (including for Hangul).

    use icu::normalizer::properties::Decomposed;
    let decomp = icu::normalizer::properties::CanonicalDecompositionBorrowed::new();

    assert_eq!(decomp.decompose('e'), Decomposed::Default);
    assert_eq!(
        decomp.decompose(''),
        Decomposed::Expansion('', '\u{0302}')
    );
    assert_eq!(decomp.decompose(''), Decomposed::Expansion('', ''));
    assert_eq!(decomp.decompose('\u{212B}'), Decomposed::Singleton('Å')); // ANGSTROM SIGN
    assert_eq!(decomp.decompose('\u{2126}'), Decomposed::Singleton('Ω')); // OHM SIGN
    assert_eq!(decomp.decompose('\u{1F71}'), Decomposed::Singleton('ά')); // oxia

impl CanonicalDecompositionBorrowed<'static>

const fn static_to_owned(self: Self) -> CanonicalDecomposition

Cheaply converts a [CanonicalDecompositionBorrowed<'static>] into a CanonicalDecomposition.

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

const fn new() -> Self

Construct from compiled data.

Enabled with the compiled_data Cargo feature.

📚 Help choosing a constructor

impl Default for CanonicalDecompositionBorrowed<'static>

fn default() -> Self

impl<'a> Debug for CanonicalDecompositionBorrowed<'a>

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

impl<'a> Freeze for CanonicalDecompositionBorrowed<'a>

impl<'a> RefUnwindSafe for CanonicalDecompositionBorrowed<'a>

impl<'a> Send for CanonicalDecompositionBorrowed<'a>

impl<'a> Sync for CanonicalDecompositionBorrowed<'a>

impl<'a> Unpin for CanonicalDecompositionBorrowed<'a>

impl<'a> UnsafeUnpin for CanonicalDecompositionBorrowed<'a>

impl<'a> UnwindSafe for CanonicalDecompositionBorrowed<'a>

impl<T> Any for CanonicalDecompositionBorrowed<'a>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for CanonicalDecompositionBorrowed<'a>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for CanonicalDecompositionBorrowed<'a>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> ErasedDestructor for CanonicalDecompositionBorrowed<'a>

impl<T> From for CanonicalDecompositionBorrowed<'a>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for CanonicalDecompositionBorrowed<'a>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for CanonicalDecompositionBorrowed<'a>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for CanonicalDecompositionBorrowed<'a>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>