Move conversion logic from unicode.py to mapping_table.rs

Author: Clar Charr

src/libcore/char/methods.rs

@@ -779,7 +779,7 @@ impl char {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn to_lowercase(self) -> ToLowercase {
-        ToLowercase(CaseMappingIter::new(conversions::to_lower(self)))
+        ToLowercase(conversions::Lowercase.lookup(self))
     }
 
     /// Returns an iterator that yields the uppercase equivalent of a `char`
@@ -865,7 +865,7 @@ impl char {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn to_uppercase(self) -> ToUppercase {
-        ToUppercase(CaseMappingIter::new(conversions::to_upper(self)))
+        ToUppercase(conversions::Uppercase.lookup(self))
     }
 
     /// Checks if the value is within the ASCII range.

src/libcore/char/mod.rs

@@ -58,6 +58,7 @@ pub use self::decode::{decode_utf8, DecodeUtf8, InvalidSequence};
 
 use fmt::{self, Write};
 use iter::FusedIterator;
+use unicode::mapping_table::Lookup;
 
 // UTF-8 ranges and tags for encoding characters
 const TAG_CONT: u8    = 0b1000_0000;
@@ -396,19 +397,33 @@ impl fmt::Display for EscapeDebug {
 /// [`char`]: ../../std/primitive.char.html
 #[stable(feature = "rust1", since = "1.0.0")]
 #[derive(Debug, Clone)]
-pub struct ToLowercase(CaseMappingIter);
+pub struct ToLowercase(Lookup);
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Iterator for ToLowercase {
     type Item = char;
+
+    #[inline]
     fn next(&mut self) -> Option<char> {
         self.0.next()
     }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
 }
 
 #[stable(feature = "fused", since = "1.26.0")]
 impl FusedIterator for ToLowercase {}
 
+#[stable(feature = "char_struct_display", since = "1.16.0")]
+impl fmt::Display for ToLowercase {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(&self.0, f)
+    }
+}
+
 /// Returns an iterator that yields the uppercase equivalent of a `char`.
 ///
 /// This `struct` is created by the [`to_uppercase`] method on [`char`]. See
@@ -418,88 +433,25 @@ impl FusedIterator for ToLowercase {}
 /// [`char`]: ../../std/primitive.char.html
 #[stable(feature = "rust1", since = "1.0.0")]
 #[derive(Debug, Clone)]
-pub struct ToUppercase(CaseMappingIter);
+pub struct ToUppercase(Lookup);
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Iterator for ToUppercase {
     type Item = char;
-    fn next(&mut self) -> Option<char> {
-        self.0.next()
-    }
-}
-
-#[stable(feature = "fused", since = "1.26.0")]
-impl FusedIterator for ToUppercase {}
-
-#[derive(Debug, Clone)]
-enum CaseMappingIter {
-    Three(char, char, char),
-    Two(char, char),
-    One(char),
-    Zero,
-}
-
-impl CaseMappingIter {
-    fn new(chars: [char; 3]) -> CaseMappingIter {
-        if chars[2] == '\0' {
-            if chars[1] == '\0' {
-                CaseMappingIter::One(chars[0])  // Including if chars[0] == '\0'
-            } else {
-                CaseMappingIter::Two(chars[0], chars[1])
-            }
-        } else {
-            CaseMappingIter::Three(chars[0], chars[1], chars[2])
-        }
-    }
-}
 
-impl Iterator for CaseMappingIter {
-    type Item = char;
+    #[inline]
     fn next(&mut self) -> Option<char> {
-        match *self {
-            CaseMappingIter::Three(a, b, c) => {
-                *self = CaseMappingIter::Two(b, c);
-                Some(a)
-            }
-            CaseMappingIter::Two(b, c) => {
-                *self = CaseMappingIter::One(c);
-                Some(b)
-            }
-            CaseMappingIter::One(c) => {
-                *self = CaseMappingIter::Zero;
-                Some(c)
-            }
-            CaseMappingIter::Zero => None,
-        }
+        self.0.next()
     }
-}
 
-impl fmt::Display for CaseMappingIter {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            CaseMappingIter::Three(a, b, c) => {
-                f.write_char(a)?;
-                f.write_char(b)?;
-                f.write_char(c)
-            }
-            CaseMappingIter::Two(b, c) => {
-                f.write_char(b)?;
-                f.write_char(c)
-            }
-            CaseMappingIter::One(c) => {
-                f.write_char(c)
-            }
-            CaseMappingIter::Zero => Ok(()),
-        }
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
     }
 }
 
-#[stable(feature = "char_struct_display", since = "1.16.0")]
-impl fmt::Display for ToLowercase {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(&self.0, f)
-    }
-}
+#[stable(feature = "fused", since = "1.26.0")]
+impl FusedIterator for ToUppercase {}
 
 #[stable(feature = "char_struct_display", since = "1.16.0")]
 impl fmt::Display for ToUppercase {

src/libcore/unicode/mapping_table.rs

@@ -0,0 +1,83 @@
+// Copyright 2012-2014 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 fmt;
+use iter::Cloned;
+use slice::Iter;
+
+/// This is just a table which allows mapping from a character to a string,
+/// which at the moment is only used for `to_lowercase` and `to_uppercase`.
+pub struct MappingTable {
+    pub(crate) table: &'static [(char, [char; 3])],
+}
+impl MappingTable {
+    pub fn lookup(&self, c: char) -> Lookup {
+        let search = self.table.binary_search_by(|&(key, _)| key.cmp(&c)).ok();
+        match search {
+            None => Lookup(LookupInner::Same(c)),
+            Some(index) => {
+                let s = &self.table[index].1;
+                match s.iter().position(|&c| c == '\0') {
+                    None => Lookup(LookupInner::Iter(s.iter().cloned())),
+                    Some(p) => Lookup(LookupInner::Iter(s[..p].iter().cloned())),
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone)]
+pub enum LookupInner {
+    Same(char),
+    Iter(Cloned<Iter<'static, char>>),
+}
+
+/// Iterator over the characters in a mapping.
+#[derive(Clone)]
+pub struct Lookup(LookupInner);
+
+impl Iterator for Lookup {
+    type Item = char;
+
+    #[inline]
+    fn next(&mut self) -> Option<char> {
+        let next;
+        match &mut self.0 {
+            LookupInner::Iter(iter) => return iter.next(),
+            LookupInner::Same(c) => {
+                next = *c;
+            }
+        }
+        self.0 = LookupInner::Iter([].iter().cloned());
+        Some(next)
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match &self.0 {
+            LookupInner::Same(_) => (1, Some(1)),
+            LookupInner::Iter(iter) => iter.size_hint(),
+        }
+    }
+}
+
+impl fmt::Debug for Lookup {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_list().entries(self.clone()).finish()
+    }
+}
+
+impl fmt::Display for Lookup {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        for c in self.clone() {
+            fmt::Write::write_char(f, c)?;
+        }
+        Ok(())
+    }
+}

src/libcore/unicode/mod.rs

@@ -12,6 +12,7 @@
 #![allow(missing_docs)]
 
 mod bool_trie;
+pub(crate) mod mapping_table;
 pub(crate) mod printable;
 pub(crate) mod tables;
 pub(crate) mod version;