Struct `CanonicalCompositionBorrowed`

struct CanonicalCompositionBorrowed<'a> { ... }

Borrowed version of the raw canonical composition operation.

Callers should generally use ComposingNormalizer instead of this API. However, this API is provided for callers such as HarfBuzz that specifically want access to the raw canonical composition operation e.g. for use in a glyph-availability-guided custom normalizer.

Implementations

`impl CanonicalCompositionBorrowed<'_>`

fn compose(self: Self, starter: char, second: char) -> Option<char>

Performs canonical composition (including Hangul) on a pair of characters or returns None if these characters don't compose. Composition exclusions are taken into account.

Examples

let comp = icu::normalizer::properties::CanonicalCompositionBorrowed::new();

assert_eq!(comp.compose('a', 'b'), None); // Just two non-composing starters
assert_eq!(comp.compose('a', '\u{0308}'), Some('ä'));
assert_eq!(comp.compose('ẹ', '\u{0302}'), Some('ệ'));
assert_eq!(comp.compose('𝅗', '𝅥'), None); // Composition exclusion
assert_eq!(comp.compose('ে', 'া'), Some('ো')); // Second is starter
assert_eq!(comp.compose('ᄀ', 'ᅡ'), Some('가')); // Hangul LV
assert_eq!(comp.compose('가', 'ᆨ'), Some('각')); // Hangul LVT

`impl CanonicalCompositionBorrowed<'static>`

const fn static_to_owned(self: Self) -> CanonicalComposition

Cheaply converts a [CanonicalCompositionBorrowed<'static>] into a CanonicalComposition.

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

const fn new() -> Self

Constructs a new CanonicalComposition using compiled data.

✨ Enabled with the compiled_data Cargo feature.

📚 Help choosing a constructor

`impl Default for CanonicalCompositionBorrowed<'static>`

fn default() -> Self

`impl<'a> Clone for CanonicalCompositionBorrowed<'a>`

fn clone(self: &Self) -> CanonicalCompositionBorrowed<'a>

`impl<'a> Copy for CanonicalCompositionBorrowed<'a>`

`impl<'a> Debug for CanonicalCompositionBorrowed<'a>`

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

`impl<'a> Freeze for CanonicalCompositionBorrowed<'a>`

`impl<'a> RefUnwindSafe for CanonicalCompositionBorrowed<'a>`

`impl<'a> Send for CanonicalCompositionBorrowed<'a>`

`impl<'a> Sync for CanonicalCompositionBorrowed<'a>`

`impl<'a> Unpin for CanonicalCompositionBorrowed<'a>`

`impl<'a> UnsafeUnpin for CanonicalCompositionBorrowed<'a>`

`impl<'a> UnwindSafe for CanonicalCompositionBorrowed<'a>`

`impl<T> Any for CanonicalCompositionBorrowed<'a>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for CanonicalCompositionBorrowed<'a>`

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

`impl<T> BorrowMut for CanonicalCompositionBorrowed<'a>`

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

`impl<T> CloneToUninit for CanonicalCompositionBorrowed<'a>`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> ErasedDestructor for CanonicalCompositionBorrowed<'a>`

`impl<T> From for CanonicalCompositionBorrowed<'a>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for CanonicalCompositionBorrowed<'a>`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for CanonicalCompositionBorrowed<'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 CanonicalCompositionBorrowed<'a>`

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

`impl<T, U> TryInto for CanonicalCompositionBorrowed<'a>`

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