+// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+use std::fmt::{self, Write};
+
+#[derive(Clone)]
+enum DecompositionType {
+    Canonical,
+    Compatible
+}
+
+/// External iterator for a string decomposition's characters.
+#[derive(Clone)]
+pub struct Decompositions<I> {
+    kind: DecompositionType,
+    iter: I,
+    done: bool,
+
+    // This buffer stores pairs of (canonical combining class, character),
+    // pushed onto the end in text order.
+    //
+    // It's split into two contiguous regions by the `ready` offset.  The first
+    // `ready` pairs are sorted and ready to emit on demand.  The "pending"
+    // suffix afterwards still needs more characters for us to be able to sort
+    // in canonical order and is not safe to emit.
+    buffer: Vec<(u8, char)>,
+    ready: usize,
+}
+
+#[inline]
+pub fn new_canonical<I: Iterator<Item=char>>(iter: I) -> Decompositions<I> {
+    Decompositions {
+        kind: self::DecompositionType::Canonical,
+        iter: iter,
+        done: false,
+        buffer: Vec::new(),
+        ready: 0,
+    }
+}
+
+#[inline]
+pub fn new_compatible<I: Iterator<Item=char>>(iter: I) -> Decompositions<I> {
+    Decompositions {
+        kind: self::DecompositionType::Compatible,
+        iter: iter,
+        done: false,
+        buffer: Vec::new(),
+        ready: 0,
+    }
+}
+
+impl<I> Decompositions<I> {
+    #[inline]
+    fn push_back(&mut self, ch: char) {
+        let class = super::char::canonical_combining_class(ch);
+        if class == 0 {
+            self.sort_pending();
+        }
+        self.buffer.push((class, ch));
+    }
+
+    #[inline]
+    fn sort_pending(&mut self) {
+        if self.ready == 0 && self.buffer.is_empty() {
+            return;
+        }
+
+        // NB: `sort_by_key` is stable, so it will preserve the original text's
+        // order within a combining class.
+        self.buffer[self.ready..].sort_by_key(|k| k.0);
+        self.ready = self.buffer.len();
+    }
+
+    #[inline]
+    fn pop_front(&mut self) -> Option<char> {
+        if self.ready == 0 {
+            None
+        } else {
+            self.ready -= 1;
+            Some(self.buffer.remove(0).1)
+        }
+    }
+}
+
+impl<I: Iterator<Item=char>> Iterator for Decompositions<I> {
+    type Item = char;
+
+    #[inline]
+    fn next(&mut self) -> Option<char> {
+        while self.ready == 0 && !self.done {
+            match (self.iter.next(), &self.kind) {
+                (Some(ch), &DecompositionType::Canonical) => {
+                    super::char::decompose_canonical(ch, |d| self.push_back(d));
+                },
+                (Some(ch), &DecompositionType::Compatible) => {
+                    super::char::decompose_compatible(ch, |d| self.push_back(d));
+                },
+                (None, _) => {
+                    self.sort_pending();
+                    self.done = true;
+                },
+            }
+        }
+        self.pop_front()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let (lower, _) = self.iter.size_hint();
+        (lower, None)
+    }
+}
+
+impl<I: Iterator<Item=char> + Clone> fmt::Display for Decompositions<I> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        for c in self.clone() {
+            f.write_char(c)?;
+        }
+        Ok(())
+    }
+}
+

+

Decompositions	+ External iterator for a string decomposition's characters. + +
Recompositions	+ External iterator for a string recomposition's characters. + +
StreamSafe	+ UAX15-D4: This iterator keeps track of how many non-starters there have been +since the last starter in NFKD and will emit a Combining Grapheme Joiner +(U+034F) if the count exceeds 30. + +

is_nfc	+ Authoritatively check if a string is in NFC. + +
is_nfc_quick	+ Quickly check if a string is in NFC, potentially returning +`IsNormalized::Maybe` if further checks are necessary. In this case a check +like `s.chars().nfc().eq(s.chars())` should suffice. + +
is_nfc_stream_safe	+ Authoritatively check if a string is Stream-Safe NFC. + +
is_nfc_stream_safe_quick	+ Quickly check if a string is Stream-Safe NFC. + +
is_nfd	+ Authoritatively check if a string is in NFD. + +
is_nfd_quick	+ Quickly check if a string is in NFD. + +
is_nfd_stream_safe	+ Authoritatively check if a string is Stream-Safe NFD. + +
is_nfd_stream_safe_quick	+ Quickly check if a string is Stream-Safe NFD. + +

canonical_combining_class	+ +
compose	+ Compose two characters into a single character, if possible. +See Unicode Standard Annex #15 +for more information. + +
decompose_canonical	+ Compute canonical Unicode decomposition for character. +See Unicode Standard Annex #15 +for more information. + +
decompose_compatible	+ Compute canonical or compatible Unicode decomposition for character. +See Unicode Standard Annex #15 +for more information. + +
is_combining_mark	+ +

Results for ' + escape(query.query) + + (query.type ? ' (type: ' + escape(query.type) + ')' : '') + '

Function unicode_normalization::char::canonical_combining_class + + [−] + + [src]

Function unicode_normalization::char::compose + + [−] + + [src]

Function unicode_normalization::char::decompose_canonical + + [−] + + [src]

Function unicode_normalization::char::decompose_compatible + + [−] + + [src]

Function unicode_normalization::char::is_combining_mark + + [−] + + [src]

Module unicode_normalization::char + + [−] + + [src]

Constant unicode_normalization::UNICODE_VERSION + + [−] + + [src]

Enum unicode_normalization::IsNormalized + + [−] + + [src]

+ Variants

+ Trait Implementations +

impl Debug for IsNormalized[src]

fn fmt(&self, __arg_0: &mut Formatter) -> Result[src]

impl Eq for IsNormalized[src]

impl PartialEq for IsNormalized[src]

fn eq(&self, __arg_0: &IsNormalized) -> bool[src]

fn ne(&self, other: &Rhs) -> bool1.0.0[src]

Function unicode_normalization::is_nfc + + [−] + + [src]

Function unicode_normalization::is_nfc_quick + + [−] + + [src]

Function unicode_normalization::is_nfc_stream_safe + + [−] + + [src]

Function unicode_normalization::is_nfc_stream_safe_quick + + [−] + + [src]

Function unicode_normalization::is_nfd + + [−] + + [src]

Function unicode_normalization::is_nfd_quick + + [−] + + [src]

Function unicode_normalization::is_nfd_stream_safe + + [−] + + [src]

Function unicode_normalization::is_nfd_stream_safe_quick + + [−] + + [src]

Crate unicode_normalization + + [−] + + [src]

Struct unicode_normalization::Decompositions + + [−] + + [src]

+ Trait Implementations +

impl<I: Clone> Clone for Decompositions<I>[src]

ⓘImportant traits for Decompositions<I>Important traits for Decompositions<I>impl<I: Iterator<Item = char>> Iterator for Decompositions<I> type Item = char;fn clone(&self) -> Decompositions<I>[src]

Important traits for Decompositions<I>

fn clone_from(&mut self, source: &Self)1.0.0[src]

impl<I: Iterator<Item = char>> Iterator for Decompositions<I>[src]

type Item = char

fn next(&mut self) -> Option<char>[src]

fn size_hint(&self) -> (usize, Option<usize>)[src]

fn count(self) -> usize1.0.0[src]

fn last(self) -> Option<Self::Item>1.0.0[src]

fn nth(&mut self, n: usize) -> Option<Self::Item>1.0.0[src]

fn step_by(self, step: usize) -> StepBy<Self>[src]

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where U: IntoIterator<Item = Self::Item>, 1.0.0[src]

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where U: IntoIterator, 1.0.0[src]

fn map<B, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> B, 1.0.0[src]

fn for_each<F>(self, f: F) where F: FnMut(Self::Item), 1.21.0[src]

fn filter<P>(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool, 1.0.0[src]

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option<B>, 1.0.0[src]

fn enumerate(self) -> Enumerate<Self>1.0.0[src]

fn peekable(self) -> Peekable<Self>1.0.0[src]

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where P: FnMut(&Self::Item) -> bool, 1.0.0[src]

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where P: FnMut(&Self::Item) -> bool, 1.0.0[src]

fn skip(self, n: usize) -> Skip<Self>1.0.0[src]

fn take(self, n: usize) -> Take<Self>1.0.0[src]

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where F: FnMut(&mut St, Self::Item) -> Option<B>, 1.0.0[src]

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where F: FnMut(Self::Item) -> U, U: IntoIterator, 1.0.0[src]

fn fuse(self) -> Fuse<Self>1.0.0[src]

fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item), 1.0.0[src]

fn by_ref(&mut self) -> &mut Self1.0.0[src]

fn collect<B>(self) -> B where B: FromIterator<Self::Item>, 1.0.0[src]

fn partition<B, F>(self, f: F) -> (B, B) where B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool, 1.0.0[src]

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where F: FnMut(B, Self::Item) -> R, R: Try<Ok = B>, [src]

fn fold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, Self::Item) -> B, 1.0.0[src]

fn all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool, 1.0.0[src]

fn any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool, 1.0.0[src]

fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool, 1.0.0[src]

fn position<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool, 1.0.0[src]

fn rposition<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool, Self: ExactSizeIterator + DoubleEndedIterator, 1.0.0[src]

fn max(self) -> Option<Self::Item> where Self::Item: Ord, 1.0.0[src]

fn min(self) -> Option<Self::Item> where Self::Item: Ord, 1.0.0[src]

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B, 1.6.0[src]

fn max_by<F>(self, compare: F) -> Option<Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering, 1.15.0[src]

`impl Debug for IsNormalized`
[src]

`fn fmt(&self, __arg_0: &mut Formatter) -> Result`
[src]

`impl Eq for IsNormalized`
[src]

`impl PartialEq for IsNormalized`
[src]

`fn eq(&self, __arg_0: &IsNormalized) -> bool`
[src]

`fn ne(&self, other: &Rhs) -> bool`
1.0.0
[src]

`impl<I: Clone> Clone for Decompositions<I>`
[src]

ⓘImportant traits for Decompositions<I>
Important traits for Decompositions<I>
`impl<I: Iterator<Item = char>> Iterator for Decompositions<I> type Item = char;`
`fn clone(&self) -> Decompositions<I>`
[src]

`fn clone_from(&mut self, source: &Self)`
1.0.0
[src]

`impl<I: Iterator<Item = char>> Iterator for Decompositions<I>`
[src]

`type Item = char`

`fn next(&mut self) -> Option<char>`
[src]

`fn size_hint(&self) -> (usize, Option<usize>)`
[src]

`fn count(self) -> usize`
1.0.0
[src]

`fn last(self) -> Option<Self::Item>`
1.0.0
[src]

`fn nth(&mut self, n: usize) -> Option<Self::Item>`
1.0.0
[src]

`fn step_by(self, step: usize) -> StepBy<Self>`
[src]

`fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where U: IntoIterator<Item = Self::Item>,`
1.0.0
[src]

`fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where U: IntoIterator,`
1.0.0
[src]

`fn map<B, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> B,`
1.0.0
[src]

`fn for_each<F>(self, f: F) where F: FnMut(Self::Item),`
1.21.0
[src]

`fn filter<P>(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool,`
1.0.0
[src]

`fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option<B>,`
1.0.0
[src]

`fn enumerate(self) -> Enumerate<Self>`
1.0.0
[src]

`fn peekable(self) -> Peekable<Self>`
1.0.0
[src]

`fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where P: FnMut(&Self::Item) -> bool,`
1.0.0
[src]

`fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where P: FnMut(&Self::Item) -> bool,`
1.0.0
[src]

`fn skip(self, n: usize) -> Skip<Self>`
1.0.0
[src]

`fn take(self, n: usize) -> Take<Self>`
1.0.0
[src]

`fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where F: FnMut(&mut St, Self::Item) -> Option<B>,`
1.0.0
[src]

`fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where F: FnMut(Self::Item) -> U, U: IntoIterator,`
1.0.0
[src]

`fn fuse(self) -> Fuse<Self>`
1.0.0
[src]

`fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item),`
1.0.0
[src]

`fn by_ref(&mut self) -> &mut Self`
1.0.0
[src]

`fn collect<B>(self) -> B where B: FromIterator<Self::Item>,`
1.0.0
[src]

`fn partition<B, F>(self, f: F) -> (B, B) where B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,`
1.0.0
[src]

`fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where F: FnMut(B, Self::Item) -> R, R: Try<Ok = B>,`
[src]

`fn fold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, Self::Item) -> B,`
1.0.0
[src]

`fn all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool,`
1.0.0
[src]

`fn any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool,`
1.0.0
[src]

`fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool,`
1.0.0
[src]

`fn position<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool,`
1.0.0
[src]

`fn rposition<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool, Self: ExactSizeIterator + DoubleEndedIterator,`
1.0.0
[src]

`fn max(self) -> Option<Self::Item> where Self::Item: Ord,`
1.0.0
[src]

`fn min(self) -> Option<Self::Item> where Self::Item: Ord,`
1.0.0
[src]

`fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B,`
1.6.0
[src]

`fn max_by<F>(self, compare: F) -> Option<Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering,`
1.15.0
[src]