Struct ComposingNormalizerBorrowed 

pub struct ComposingNormalizerBorrowed<'a> {
    pub(crate) decomposing_normalizer: DecomposingNormalizerBorrowed<'a>,
    pub(crate) canonical_compositions: CanonicalCompositionsBorrowed<'a>,
}

Borrowed version of a normalizer for performing composing normalization.

Fields

decomposing_normalizer: DecomposingNormalizerBorrowed<'a>

canonical_compositions: CanonicalCompositionsBorrowed<'a>

Implementations

impl ComposingNormalizerBorrowed<'static>

pub const fn static_to_owned(self) -> ComposingNormalizer

Cheaply converts a ComposingNormalizerBorrowed<'static> into a ComposingNormalizer.

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

pub const fn new_nfc() -> Self

NFC constructor using compiled data.

✨ Enabled with the compiled_data Cargo feature.

📚 Help choosing a constructor

pub const fn new_nfkc() -> Self

NFKC constructor using compiled data.

✨ Enabled with the compiled_data Cargo feature.

📚 Help choosing a constructor

pub(crate) const fn new_uts46() -> Self

This is a special building block normalization for IDNA that implements parts of the Map step and the following Normalize step.

Warning: In this normalization, U+0345 COMBINING GREEK YPOGEGRAMMENI exhibits a behavior that no character in Unicode exhibits in NFD, NFKD, NFC, or NFKC: Case folding turns U+0345 from a reordered character into a non-reordered character before reordering happens. Therefore, the output of this normalization may differ for different inputs that are canonically equivalents with each other if they differ by how U+0345 is ordered relative to other reorderable characters.

impl<'data> ComposingNormalizerBorrowed<'data>

pub fn normalize_iter<I: Iterator<Item = char>>( &'data self, iter: I, ) -> Composition<'data, I>

Wraps a delegate iterator into a composing iterator adapter by using the data already held by this normalizer.

pub(crate) fn normalize_iter_private<I: Iterator<Item = (char, u32)> + WithTrie<'data, T, u32>, T: AbstractCodePointTrie<'data, u32> + 'data, P: IteratorPolicy>( &'data self, iter: I, ) -> CompositionInner<'data, I, T, P>

There’s an extra U+FFFD at the start. The caller must deal with it.

pub(crate) fn trie<T: AbstractCodePointTrie<'data, u32>>(&self) -> &'data T

where &'data T: TryFrom<&'data CodePointTrie<'data, u32>>,

pub fn normalize<'a>(&self, text: &'a str) -> Cow<'a, str>

Normalize a string slice into a Cow<'a, str>.

pub fn split_normalized<'a>(&self, text: &'a str) -> (&'a str, &'a str)

Split a string slice into maximum normalized prefix and unnormalized suffix such that the concatenation of the prefix and the normalization of the suffix is the normalization of the whole input.

pub(crate) fn is_normalized_up_to(&self, text: &str) -> usize

Return the index a string slice is normalized up to.

pub fn is_normalized(&self, text: &str) -> bool

Check whether a string slice is normalized.

pub fn normalize_utf16<'a>(&self, text: &'a [u16]) -> Cow<'a, [u16]>

Normalize a slice of potentially-invalid UTF-16 into a Cow<'a, [u16]>.

Unpaired surrogates are mapped to the REPLACEMENT CHARACTER before normalizing.

✨ Enabled with the utf16_iter Cargo feature.

pub fn split_normalized_utf16<'a>( &self, text: &'a [u16], ) -> (&'a [u16], &'a [u16])

Split a slice of potentially-invalid UTF-16 into maximum normalized (and valid) prefix and unnormalized suffix such that the concatenation of the prefix and the normalization of the suffix is the normalization of the whole input.

✨ Enabled with the utf16_iter Cargo feature.

pub(crate) fn is_normalized_utf16_up_to(&self, text: &[u16]) -> usize

Return the index a slice of potentially-invalid UTF-16 is normalized up to.

✨ Enabled with the utf16_iter Cargo feature.

pub fn is_normalized_utf16(&self, text: &[u16]) -> bool

Checks whether a slice of potentially-invalid UTF-16 is normalized.

Unpaired surrogates are treated as the REPLACEMENT CHARACTER.

✨ Enabled with the utf16_iter Cargo feature.

pub fn normalize_utf8<'a>(&self, text: &'a [u8]) -> Cow<'a, str>

Normalize a slice of potentially-invalid UTF-8 into a Cow<'a, str>.

Ill-formed byte sequences are mapped to the REPLACEMENT CHARACTER according to the WHATWG Encoding Standard.

✨ Enabled with the utf8_iter Cargo feature.

pub fn split_normalized_utf8<'a>(&self, text: &'a [u8]) -> (&'a str, &'a [u8])

Split a slice of potentially-invalid UTF-8 into maximum normalized (and valid) prefix and unnormalized suffix such that the concatenation of the prefix and the normalization of the suffix is the normalization of the whole input.

✨ Enabled with the utf8_iter Cargo feature.

pub(crate) fn is_normalized_utf8_up_to(&self, text: &[u8]) -> usize

Return the index a slice of potentially-invalid UTF-8 is normalized up to

✨ Enabled with the utf8_iter Cargo feature.

pub fn is_normalized_utf8(&self, text: &[u8]) -> bool

Check if a slice of potentially-invalid UTF-8 is normalized.

Ill-formed byte sequences are mapped to the REPLACEMENT CHARACTER according to the WHATWG Encoding Standard before checking.

✨ Enabled with the utf8_iter Cargo feature.

pub fn normalize_to<W: Write + ?Sized>( &self, text: &str, sink: &mut W, ) -> Result

Normalize a string slice into a Write sink.

pub fn normalize_utf8_to<W: Write + ?Sized>( &self, text: &[u8], sink: &mut W, ) -> Result

Normalize a slice of potentially-invalid UTF-8 into a Write sink.

Ill-formed byte sequences are mapped to the REPLACEMENT CHARACTER according to the WHATWG Encoding Standard.

✨ Enabled with the utf8_iter Cargo feature.

pub fn normalize_utf16_to<W: Write16 + ?Sized>( &self, text: &[u16], sink: &mut W, ) -> Result

Normalize a slice of potentially-invalid UTF-16 into a Write16 sink.

Unpaired surrogates are mapped to the REPLACEMENT CHARACTER before normalizing.

✨ Enabled with the utf16_iter Cargo feature.

Trait Implementations

impl<'a> Debug for ComposingNormalizerBorrowed<'a>

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

Formats the value using the given formatter.