Add a helper TinyStr crate

Cargo.toml

@@ -8,4 +8,5 @@ members = [
     "unic-locale-impl",
     "unic-locale-macros",
     "unic-locale-macros-impl",
+    "tinystr",
 ]

tinystr/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "tinystr"
+version = "0.1.0"
+authors = ["Raph Levien <[email protected]>", "Zibi Braniecki <[email protected]>"]
+edition = "2018"
+
+[dev-dependencies]
+criterion = "0.2"
+
+[[bench]]
+name = "tinystr4"
+harness = false
+
+[[bench]]
+name = "tinystr8"
+harness = false
+
+[[bench]]
+name = "string"
+harness = false

tinystr/benches/string.rs

@@ -0,0 +1,86 @@
+use criterion::black_box;
+use criterion::criterion_group;
+use criterion::criterion_main;
+use criterion::Criterion;
+use criterion::Fun;
+
+static STRINGS: &[&str] = &[
+    "US", "GB", "AR", "Hans", "CN", "AT", "PL", "FR", "AT", "Cyrl", "SR", "NO", "FR", "MK", "UK",
+];
+
+fn string_bench_construct(c: &mut Criterion) {
+    let strings = STRINGS;
+
+    let funcs = vec![Fun::new("from_str", |b, strings: &Vec<&str>| {
+        b.iter(|| {
+            for s in strings {
+                let _: Result<String, _> = black_box(s).parse();
+            }
+        })
+    })];
+
+    c.bench_functions("String_construct", funcs, strings.to_vec());
+}
+
+fn string_bench_convert(c: &mut Criterion) {
+    let strings: Vec<String> = STRINGS.iter().map(|s| s.parse().unwrap()).collect();
+
+    let funcs = vec![
+        Fun::new("as_str", |b, strings: &Vec<String>| {
+            b.iter(|| {
+                for s in strings {
+                    let _ = black_box(s).as_str();
+                }
+            })
+        }),
+        Fun::new("to_ascii_uppercase", |b, strings: &Vec<String>| {
+            b.iter(|| {
+                for s in strings {
+                    let _ = black_box(s).to_ascii_uppercase();
+                }
+            })
+        }),
+        Fun::new("to_ascii_lowercase", |b, strings: &Vec<String>| {
+            b.iter(|| {
+                for s in strings {
+                    let _ = black_box(s).to_ascii_lowercase();
+                }
+            })
+        }),
+        Fun::new("to_ascii_titlecase", |b, strings: &Vec<String>| {
+            b.iter(|| {
+                for s in strings {
+                    let mut result = s.to_ascii_lowercase();
+                    result[0..1].make_ascii_uppercase();
+                }
+            })
+        }),
+    ];
+
+    c.bench_functions("String_convert", funcs, strings);
+}
+
+fn string_bench_test(c: &mut Criterion) {
+    let strings: Vec<String> = STRINGS.iter().map(|s| s.parse().unwrap()).collect();
+
+    let funcs = vec![Fun::new(
+        "is_all_ascii_alphanumeric",
+        |b, strings: &Vec<String>| {
+            b.iter(|| {
+                for s in strings {
+                    let _ = black_box(s).chars().all(|c| c.is_ascii_alphanumeric());
+                }
+            })
+        },
+    )];
+
+    c.bench_functions("String_test", funcs, strings);
+}
+
+criterion_group!(
+    benches,
+    string_bench_construct,
+    string_bench_convert,
+    string_bench_test,
+);
+criterion_main!(benches);

tinystr/benches/tinystr4.rs

@@ -0,0 +1,100 @@
+use criterion::black_box;
+use criterion::criterion_group;
+use criterion::criterion_main;
+use criterion::Criterion;
+use criterion::Fun;
+
+use tinystr::TinyStr4;
+
+static STRINGS: &[&str] = &[
+    "US", "GB", "AR", "Hans", "CN", "AT", "PL", "FR", "AT", "Cyrl", "SR", "NO", "FR", "MK", "UK",
+];
+
+fn tinystr4_bench_construct(c: &mut Criterion) {
+    let strings = STRINGS;
+
+    let funcs = vec![
+        Fun::new("from_str", |b, strings: &Vec<&str>| {
+            b.iter(|| {
+                for s in strings {
+                    let _: Result<TinyStr4, _> = black_box(s).parse();
+                }
+            })
+        }),
+        Fun::new("new_unchecked", |b, strings: &Vec<&str>| {
+            let raw: Vec<u32> = strings
+                .iter()
+                .map(|s| s.parse::<TinyStr4>().unwrap().into())
+                .collect();
+            b.iter(move || {
+                for num in &raw {
+                    let _ = unsafe { TinyStr4::new_unchecked(black_box(*num)) };
+                }
+            })
+        }),
+    ];
+
+    c.bench_functions("tinystr4_construct", funcs, strings.to_vec());
+}
+
+fn tinystr4_bench_convert(c: &mut Criterion) {
+    let strings: Vec<TinyStr4> = STRINGS.iter().map(|s| s.parse().unwrap()).collect();
+
+    let funcs = vec![
+        Fun::new("as_str", |b, strings: &Vec<TinyStr4>| {
+            b.iter(|| {
+                for s in strings {
+                    let _ = black_box(s).as_str();
+                }
+            })
+        }),
+        Fun::new("to_ascii_uppercase", |b, strings: &Vec<TinyStr4>| {
+            b.iter(|| {
+                for s in strings {
+                    let _ = black_box(s).to_ascii_uppercase();
+                }
+            })
+        }),
+        Fun::new("to_ascii_lowercase", |b, strings: &Vec<TinyStr4>| {
+            b.iter(|| {
+                for s in strings {
+                    let _ = black_box(s).to_ascii_lowercase();
+                }
+            })
+        }),
+        Fun::new("to_ascii_titlecase", |b, strings: &Vec<TinyStr4>| {
+            b.iter(|| {
+                for s in strings {
+                    let _ = black_box(s).to_ascii_titlecase();
+                }
+            })
+        }),
+    ];
+
+    c.bench_functions("tinystr4_convert", funcs, strings);
+}
+
+fn tinystr4_bench_test(c: &mut Criterion) {
+    let strings: Vec<TinyStr4> = STRINGS.iter().map(|s| s.parse().unwrap()).collect();
+
+    let funcs = vec![Fun::new(
+        "is_all_ascii_alphanumeric",
+        |b, strings: &Vec<TinyStr4>| {
+            b.iter(|| {
+                for s in strings {
+                    let _ = black_box(s).is_all_ascii_alphanumeric();
+                }
+            })
+        },
+    )];
+
+    c.bench_functions("tinystr4_test", funcs, strings);
+}
+
+criterion_group!(
+    benches,
+    tinystr4_bench_construct,
+    tinystr4_bench_convert,
+    tinystr4_bench_test,
+);
+criterion_main!(benches);

tinystr/benches/tinystr8.rs

@@ -0,0 +1,93 @@
+use criterion::black_box;
+use criterion::criterion_group;
+use criterion::criterion_main;
+use criterion::Criterion;
+use criterion::Fun;
+
+use tinystr::TinyStr8;
+
+static STRINGS: &[&str] = &[
+    "US", "GB", "AR", "Hans", "CN", "AT", "PL", "FR", "AT", "Cyrl", "SR", "NO", "FR", "MK", "UK",
+];
+
+fn tinystr8_bench_construct(c: &mut Criterion) {
+    let strings = STRINGS;
+
+    let funcs = vec![
+        Fun::new("from_str", |b, strings: &Vec<&str>| {
+            b.iter(|| {
+                for s in strings {
+                    let _: Result<TinyStr8, _> = black_box(s).parse();
+                }
+            })
+        }),
+        Fun::new("new_unchecked", |b, strings: &Vec<&str>| {
+            let raw: Vec<u64> = strings
+                .iter()
+                .map(|s| s.parse::<TinyStr8>().unwrap().into())
+                .collect();
+            b.iter(move || {
+                for num in &raw {
+                    let _ = unsafe { TinyStr8::new_unchecked(black_box(*num)) };
+                }
+            })
+        }),
+    ];
+
+    c.bench_functions("tinystr8_construct", funcs, strings.to_vec());
+}
+
+fn tinystr8_bench_convert(c: &mut Criterion) {
+    let strings: Vec<TinyStr8> = STRINGS.iter().map(|s| s.parse().unwrap()).collect();
+
+    let funcs = vec![
+        Fun::new("as_str", |b, strings: &Vec<TinyStr8>| {
+            b.iter(|| {
+                for s in strings {
+                    let _ = black_box(s).as_str();
+                }
+            })
+        }),
+        Fun::new("to_ascii_uppercase", |b, strings: &Vec<TinyStr8>| {
+            b.iter(|| {
+                for s in strings {
+                    let _ = black_box(s).to_ascii_uppercase();
+                }
+            })
+        }),
+        Fun::new("to_ascii_lowercase", |b, strings: &Vec<TinyStr8>| {
+            b.iter(|| {
+                for s in strings {
+                    let _ = black_box(s).to_ascii_lowercase();
+                }
+            })
+        }),
+    ];
+
+    c.bench_functions("tinystr8_convert", funcs, strings);
+}
+
+fn tinystr8_bench_test(c: &mut Criterion) {
+    let strings: Vec<TinyStr8> = STRINGS.iter().map(|s| s.parse().unwrap()).collect();
+
+    let funcs = vec![Fun::new(
+        "is_all_ascii_alphanumeric",
+        |b, strings: &Vec<TinyStr8>| {
+            b.iter(|| {
+                for s in strings {
+                    let _ = black_box(s).is_all_ascii_alphanumeric();
+                }
+            })
+        },
+    )];
+
+    c.bench_functions("tinystr8_test", funcs, strings);
+}
+
+criterion_group!(
+    benches,
+    tinystr8_bench_construct,
+    tinystr8_bench_convert,
+    tinystr8_bench_test,
+);
+criterion_main!(benches);

tinystr/src/helpers.rs

@@ -0,0 +1,22 @@
+use std::num::NonZeroU32;
+use std::ptr::copy_nonoverlapping;
+
+use super::Error;
+
+pub(crate) unsafe fn make_4byte_str(
+    text: &str,
+    len: usize,
+    mask: u32,
+) -> Result<NonZeroU32, Error> {
+    // Mask is always supplied as little-endian.
+    let mask = u32::from_le(mask);
+    let mut word: u32 = 0;
+    copy_nonoverlapping(text.as_ptr(), &mut word as *mut u32 as *mut u8, len);
+    if (word & mask) != 0 {
+        return Err(Error::NonAscii);
+    }
+    if ((mask - word) & mask) != 0 {
+        return Err(Error::InvalidNull);
+    }
+    Ok(NonZeroU32::new_unchecked(word))
+}

tinystr/src/lib.rs

@@ -0,0 +1,13 @@
+mod helpers;
+mod tinystr4;
+mod tinystr8;
+
+pub use tinystr4::TinyStr4;
+pub use tinystr8::TinyStr8;
+
+#[derive(PartialEq, Eq, Debug)]
+pub enum Error {
+    InvalidSize,
+    InvalidNull,
+    NonAscii,
+}