From df802a2754a5d536bbec264136a08d166d3bb81a Mon Sep 17 00:00:00 2001 From: Florian Zeitz Date: Mon, 12 May 2014 22:44:21 +0200 Subject: [PATCH] std: Rename str::Normalizations to str::Decompositions The Normalizations iterator has been renamed to Decompositions. It does not currently include all forms of Unicode normalization, but only encompasses decompositions. If implemented recomposition would likely be a separate iterator which works on the result of this one. [breaking-change] --- src/etc/unicode.py | 12 ++++++------ src/libcore/char.rs | 4 ++-- src/libcore/unicode.rs | 2 +- src/libstd/str.rs | 32 ++++++++++++++++---------------- src/libstd/unicode.rs | 2 +- 5 files changed, 26 insertions(+), 26 deletions(-) diff --git a/src/etc/unicode.py b/src/etc/unicode.py index f079ef73cd8e2..586890ebe4c9a 100755 --- a/src/etc/unicode.py +++ b/src/etc/unicode.py @@ -256,13 +256,13 @@ def format_table_content(f, content, indent): line = " "*indent + chunk f.write(line) -def emit_core_decomp_module(f, canon, compat): +def emit_core_norm_module(f, canon, compat): canon_keys = canon.keys() canon_keys.sort() compat_keys = compat.keys() compat_keys.sort() - f.write("pub mod decompose {\n"); + f.write("pub mod normalization {\n"); f.write(" use option::Option;\n"); f.write(" use option::{Some, None};\n"); f.write(" use slice::ImmutableVector;\n"); @@ -401,8 +401,8 @@ def emit_core_decomp_module(f, canon, compat): """) -def emit_std_decomp_module(f, combine): - f.write("pub mod decompose {\n"); +def emit_std_norm_module(f, combine): + f.write("pub mod normalization {\n"); f.write(" use option::{Some, None};\n"); f.write(" use slice::ImmutableVector;\n"); @@ -467,7 +467,7 @@ def gen_core_unicode(): emit_bsearch_range_table(rf); emit_property_module(rf, "general_category", gencats) - emit_core_decomp_module(rf, canon_decomp, compat_decomp) + emit_core_norm_module(rf, canon_decomp, compat_decomp) derived = load_properties("DerivedCoreProperties.txt", ["XID_Start", "XID_Continue", "Alphabetic", "Lowercase", "Uppercase"]) @@ -485,7 +485,7 @@ def gen_std_unicode(): with open(r, "w") as rf: # Preamble rf.write(preamble) - emit_std_decomp_module(rf, combines) + emit_std_norm_module(rf, combines) gen_core_unicode() gen_std_unicode() diff --git a/src/libcore/char.rs b/src/libcore/char.rs index 71a2d75715b5a..934483dbed423 100644 --- a/src/libcore/char.rs +++ b/src/libcore/char.rs @@ -30,9 +30,9 @@ use iter::{Iterator, range_step}; use unicode::{derived_property, property, general_category, conversions}; /// Returns the canonical decomposition of a character. -pub use unicode::decompose::decompose_canonical; +pub use unicode::normalization::decompose_canonical; /// Returns the compatibility decomposition of a character. -pub use unicode::decompose::decompose_compatible; +pub use unicode::normalization::decompose_compatible; #[cfg(not(test))] use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering}; #[cfg(not(test))] use default::Default; diff --git a/src/libcore/unicode.rs b/src/libcore/unicode.rs index bffde2323bf94..242672de2967a 100644 --- a/src/libcore/unicode.rs +++ b/src/libcore/unicode.rs @@ -104,7 +104,7 @@ pub mod general_category { } -pub mod decompose { +pub mod normalization { use option::Option; use option::{Some, None}; use slice::ImmutableVector; diff --git a/src/libstd/str.rs b/src/libstd/str.rs index 24cf9681ca84d..fa4cf8e4427d0 100644 --- a/src/libstd/str.rs +++ b/src/libstd/str.rs @@ -228,25 +228,25 @@ fn canonical_sort(comb: &mut [(char, u8)]) { } #[deriving(Clone)] -enum NormalizationForm { - NFD, - NFKD +enum DecompositionType { + Canonical, + Compatible } -/// External iterator for a string's normalization's characters. +/// External iterator for a string's decomposition's characters. /// Use with the `std::iter` module. #[deriving(Clone)] -pub struct Normalizations<'a> { - kind: NormalizationForm, +pub struct Decompositions<'a> { + kind: DecompositionType, iter: Chars<'a>, buffer: Vec<(char, u8)>, sorted: bool } -impl<'a> Iterator for Normalizations<'a> { +impl<'a> Iterator for Decompositions<'a> { #[inline] fn next(&mut self) -> Option { - use unicode::decompose::canonical_combining_class; + use unicode::normalization::canonical_combining_class; match self.buffer.as_slice().head() { Some(&(c, 0)) => { @@ -262,8 +262,8 @@ impl<'a> Iterator for Normalizations<'a> { } let decomposer = match self.kind { - NFD => char::decompose_canonical, - NFKD => char::decompose_compatible + Canonical => char::decompose_canonical, + Compatible => char::decompose_compatible }; if !self.sorted { @@ -887,24 +887,24 @@ pub trait StrAllocating: Str { /// An Iterator over the string in Unicode Normalization Form D /// (canonical decomposition). #[inline] - fn nfd_chars<'a>(&'a self) -> Normalizations<'a> { - Normalizations { + fn nfd_chars<'a>(&'a self) -> Decompositions<'a> { + Decompositions { iter: self.as_slice().chars(), buffer: Vec::new(), sorted: false, - kind: NFD + kind: Canonical } } /// An Iterator over the string in Unicode Normalization Form KD /// (compatibility decomposition). #[inline] - fn nfkd_chars<'a>(&'a self) -> Normalizations<'a> { - Normalizations { + fn nfkd_chars<'a>(&'a self) -> Decompositions<'a> { + Decompositions { iter: self.as_slice().chars(), buffer: Vec::new(), sorted: false, - kind: NFKD + kind: Compatible } } } diff --git a/src/libstd/unicode.rs b/src/libstd/unicode.rs index d534b30221b4a..03c960e96ffe1 100644 --- a/src/libstd/unicode.rs +++ b/src/libstd/unicode.rs @@ -12,7 +12,7 @@ #![allow(missing_doc, non_uppercase_statics)] -pub mod decompose { +pub mod normalization { use option::{Some, None}; use slice::ImmutableVector;