Import 'tinystr' crate
Request Document: go/android-rust-importing-crates
For CL Reviewers: go/android3p#cl-review
Bug: 391960687
Test: m libtinystr
Change-Id: I3dfd84363e038d6c302c1ae4bac745bce103b8a7
diff --git a/crates/tinystr/.android-checksum.json b/crates/tinystr/.android-checksum.json
new file mode 100644
index 0000000..4284d4f
--- /dev/null
+++ b/crates/tinystr/.android-checksum.json
@@ -0,0 +1 @@
+{"package":null,"files":{".cargo-checksum.json":"40fe32a9bdbcb74830333d95168cca69d0502168430761644c451e49c4a2f897","Android.bp":"8100be9451eaf292bd1693c44086a2c723c851b5dd0fedda13cb564a71429a20","Cargo.toml":"37876310a216d2078319c9953989999fe534415eb2e665d04b126133d7cd3783","LICENSE":"dc5bf54a256c44c7030f620e2b6abca67aa66635f54789432989d96836c552b9","METADATA":"e4d55cfc3813e6abd5d888a018a1b5da07ee163b44e43d8e63804ef701d3b74d","MODULE_LICENSE_UNICODE_3":"0d6f8afa3940b7f06bebee651376d43bc8b0d5b437337be2696d30377451e93a","README.md":"8be3be5ef96ed1f4fcff3687fd5599e4c509616a11d54fa0b6b9ed5e92efbae4","benches/common/mod.rs":"bc14c38672f31434fa69ffa3a8e528981f7ce9e31266c74ab440d0b256cd3d74","benches/construct.rs":"5be8e8401bf14d26a5bb29f3539fd7c46c3216bc83e9d2f4f87f4aa6e02643fb","benches/overview.rs":"87fe8cd30e308cca754aad387b6a002ce9c73424a03833e0a5fba95a36469ba0","benches/read.rs":"b87efa5db852883725d0211e087caabf3daed73ce75367b5b1e03a32a8427695","benches/serde.rs":"1107a358076c0a4d7ed7f2d40c229703f5ae94fd3b264c3e485c5402c69f228c","cargo_embargo.json":"ffbc75e06b34f9db852e08c0c35f26fdb7bd4ff598abb9700e8e294deb7b7768","src/ascii.rs":"55da0f850de3028c673542c8e670158ed3e2ada701595fa4d05dc8771ef8ea11","src/asciibyte.rs":"067dacb27550aea1e3060e48dcbe21c77ad00b40a53685f7d4463eaa7b44e851","src/databake.rs":"467340ca9f26b242324fbaa4d904daac25230be20c7a62ae094c40f54588b215","src/error.rs":"14fe3731f32b6eb35e64af0fb8e749adfa44751d931ab5e09fa8565433840e9f","src/int_ops.rs":"c4cc39f9128847c64c9380df3013b5318b125b05586a0dcfca18d005543fa338","src/lib.rs":"377aed1124fbad5373505a3a57e71c79709ddb80eacc84ab3f69bccb57c1b490","src/macros.rs":"8c8af8649347145a7430368dd344dbf90c3d85e2b0379ea196ede3fee5650ecf","src/serde.rs":"7d861b9b9c4dca6a535e148309d978c5497c6b8615f3cb6a33912d708aa8c0ed","src/ule.rs":"a16eda9fabc4591ec6f08453dbe9194f71ee79cb78f9de988bb0b5638cc6c725","src/unvalidated.rs":"2601bbd0d92171e52fb9d865127a4571da18c8fff6ced212cb71d3e598e60b99","tests/serde.rs":"f9137e03e3d4380f2cee38f5a7ac8f2e7a9ae2d57a482279d412ca1d7cc399a8"}}
\ No newline at end of file
diff --git a/crates/tinystr/.cargo-checksum.json b/crates/tinystr/.cargo-checksum.json
new file mode 100644
index 0000000..d1f3f38
--- /dev/null
+++ b/crates/tinystr/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"0a4ed70b64fc350c2e78702c12b88bf3b791fc96af1f76466b1a9ee8558fb4bd","LICENSE":"f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2","README.md":"b7b7a33a29865bc653a6696b079c1527ba61cd58a815fc792ed6fa5bfc680ad5","benches/common/mod.rs":"7e709fcabc2f96b10d3db8968ef3ea7fcc25e88211ce97b64b2126c7a0d7387a","benches/construct.rs":"718c4207e07091d8c16e78824f1850dbb218a02e10300117036742a6e52d2f61","benches/overview.rs":"3e5cb89dccff91ce8d53e36a6db8e548a07dd440bc6b79fb53c7b1734512dd1b","benches/read.rs":"cbf349393a50eb90e7ba53906f98a689d585242292f867a37acf6842263af4d9","benches/serde.rs":"5c88866d08c07088b82dbd5472e6276c632d11e064417f5d8f2025a5ade867f0","src/ascii.rs":"0f44edfe6f3abf5c915acf41e99c792cef1cb719e570cf65926f59735d5092e4","src/asciibyte.rs":"fa29de7403c0424c52c2f30bb47002b9abf4bd08b302c411ffe679d3decfb8de","src/databake.rs":"86d4ee8fd748a2a78dfd4ca4cfc7c3b5abdaee8c0a40f582a234793af4c459fe","src/error.rs":"0d03731df34de7e812ae13c4fe7220a4d18bdbd33459125a6170f7f37322553c","src/int_ops.rs":"0687e550ff1386aa0bfb936de8344b4161622d346c18abb332ccce4163c03183","src/lib.rs":"d879aea8654e556a518fcdf910b3eb6f115a8f1d174bceccd229dd90b8f1acf3","src/macros.rs":"c6fe247da7a7477dab2549727fca78d7476167b383628b0876fe8e3d71165507","src/serde.rs":"d45712df0dd81a7c9e07cb57d445b1d746192db90c954159aeeb59bef4ce85a0","src/ule.rs":"32f83c0e7ea9e97c0fa452df46bbd8257e2767c5329b6f4f3c75a24458ca54b8","src/unvalidated.rs":"7887cf36d4d8ed87f8352ebe188bcd1ddd89f26818a97a212eee12718c810db9","tests/serde.rs":"cf8cee82f731928375888d1b5e7e5e50368d3e16ce372fced230c9b1ee2a7451"},"package":"b2b56a820bb70060f096338fcc02edb78cb3f8fb21c5078503f48588cfcaf494"}
\ No newline at end of file
diff --git a/crates/tinystr/Android.bp b/crates/tinystr/Android.bp
new file mode 100644
index 0000000..b0e6a66
--- /dev/null
+++ b/crates/tinystr/Android.bp
@@ -0,0 +1,33 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+ default_applicable_licenses: ["external_rust_crates_tinystr_license"],
+ default_team: "trendy_team_android_rust",
+}
+
+license {
+ name: "external_rust_crates_tinystr_license",
+ visibility: [":__subpackages__"],
+ license_kinds: ["SPDX-license-identifier-Unicode-3.0"],
+ license_text: ["LICENSE"],
+}
+
+rust_library {
+ name: "libtinystr",
+ host_supported: true,
+ crate_name: "tinystr",
+ cargo_env_compat: true,
+ cargo_pkg_version: "0.8.0",
+ crate_root: "src/lib.rs",
+ edition: "2021",
+ features: ["zerovec"],
+ rustlibs: ["libzerovec"],
+ proc_macros: ["libdisplaydoc"],
+ apex_available: [
+ "//apex_available:platform",
+ "//apex_available:anyapex",
+ ],
+ product_available: true,
+ vendor_available: true,
+}
diff --git a/crates/tinystr/Cargo.toml b/crates/tinystr/Cargo.toml
new file mode 100644
index 0000000..4be086a
--- /dev/null
+++ b/crates/tinystr/Cargo.toml
@@ -0,0 +1,134 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+rust-version = "1.71.1"
+name = "tinystr"
+version = "0.8.0"
+authors = ["The ICU4X Project Developers"]
+build = false
+include = [
+ "data/**/*",
+ "src/**/*",
+ "examples/**/*",
+ "benches/**/*",
+ "tests/**/*",
+ "Cargo.toml",
+ "LICENSE",
+ "README.md",
+]
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "A small ASCII-only bounded length string representation."
+readme = "README.md"
+keywords = [
+ "string",
+ "str",
+ "small",
+ "tiny",
+ "no_std",
+]
+categories = ["data-structures"]
+license = "Unicode-3.0"
+repository = "https://github.com/unicode-org/icu4x"
+
+[package.metadata.cargo-all-features]
+denylist = ["bench"]
+
+[package.metadata.docs.rs]
+all-features = true
+
+[package.metadata.workspaces]
+independent = true
+
+[lib]
+name = "tinystr"
+path = "src/lib.rs"
+bench = false
+
+[[test]]
+name = "serde"
+path = "tests/serde.rs"
+required-features = ["serde"]
+
+[[bench]]
+name = "construct"
+path = "benches/construct.rs"
+harness = false
+required-features = ["bench"]
+
+[[bench]]
+name = "overview"
+path = "benches/overview.rs"
+harness = false
+
+[[bench]]
+name = "read"
+path = "benches/read.rs"
+harness = false
+required-features = ["bench"]
+
+[[bench]]
+name = "serde"
+path = "benches/serde.rs"
+harness = false
+required-features = [
+ "bench",
+ "serde",
+]
+
+[dependencies.databake]
+version = "0.2.0"
+optional = true
+default-features = false
+
+[dependencies.displaydoc]
+version = "0.2.3"
+default-features = false
+
+[dependencies.serde]
+version = "1.0.110"
+features = ["alloc"]
+optional = true
+default-features = false
+
+[dependencies.zerovec]
+version = "0.11.0"
+optional = true
+default-features = false
+
+[dev-dependencies.bincode]
+version = "1.3.1"
+
+[dev-dependencies.postcard]
+version = "1.0.1"
+features = ["use-std"]
+default-features = false
+
+[dev-dependencies.rand]
+version = "0.8"
+features = ["small_rng"]
+
+[dev-dependencies.serde_json]
+version = "1.0.45"
+features = ["alloc"]
+
+[features]
+alloc = []
+bench = []
+default = ["alloc"]
+std = []
+
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies.criterion]
+version = "0.5.0"
diff --git a/crates/tinystr/LICENSE b/crates/tinystr/LICENSE
new file mode 100644
index 0000000..c9be601
--- /dev/null
+++ b/crates/tinystr/LICENSE
@@ -0,0 +1,46 @@
+UNICODE LICENSE V3
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright © 2020-2024 Unicode, Inc.
+
+NOTICE TO USER: Carefully read the following legal agreement. BY
+DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING DATA FILES, AND/OR
+SOFTWARE, YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT
+DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of data files and any associated documentation (the "Data Files") or
+software and any associated documentation (the "Software") to deal in the
+Data Files or Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, and/or sell
+copies of the Data Files or Software, and to permit persons to whom the
+Data Files or Software are furnished to do so, provided that either (a)
+this copyright and permission notice appear with all copies of the Data
+Files or Software, or (b) this copyright and permission notice appear in
+associated Documentation.
+
+THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
+THIRD PARTY RIGHTS.
+
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE
+BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES,
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA
+FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder shall
+not be used in advertising or otherwise to promote the sale, use or other
+dealings in these Data Files or Software without prior written
+authorization of the copyright holder.
+
+SPDX-License-Identifier: Unicode-3.0
+
+—
+
+Portions of ICU4X may have been adapted from ICU4C and/or ICU4J.
+ICU 1.8.1 to ICU 57.1 © 1995-2016 International Business Machines Corporation and others.
diff --git a/crates/tinystr/METADATA b/crates/tinystr/METADATA
new file mode 100644
index 0000000..d24ffe4
--- /dev/null
+++ b/crates/tinystr/METADATA
@@ -0,0 +1,17 @@
+name: "tinystr"
+description: "A small ASCII-only bounded length string representation."
+third_party {
+ version: "0.8.0"
+ license_type: NOTICE
+ last_upgrade_date {
+ year: 2025
+ month: 1
+ day: 27
+ }
+ homepage: "https://crates.io/crates/tinystr"
+ identifier {
+ type: "Archive"
+ value: "https://static.crates.io/crates/tinystr/tinystr-0.8.0.crate"
+ version: "0.8.0"
+ }
+}
diff --git a/crates/tinystr/MODULE_LICENSE_UNICODE_3 b/crates/tinystr/MODULE_LICENSE_UNICODE_3
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/tinystr/MODULE_LICENSE_UNICODE_3
diff --git a/crates/tinystr/README.md b/crates/tinystr/README.md
new file mode 100644
index 0000000..92b74c0
--- /dev/null
+++ b/crates/tinystr/README.md
@@ -0,0 +1,57 @@
+# tinystr [](https://crates.io/crates/tinystr)
+
+<!-- cargo-rdme start -->
+
+`tinystr` is a utility crate of the [`ICU4X`] project.
+
+It includes [`TinyAsciiStr`], a core API for representing small ASCII-only bounded length strings.
+
+It is optimized for operations on strings of size 8 or smaller. When use cases involve comparison
+and conversion of strings for lowercase/uppercase/titlecase, or checking
+numeric/alphabetic/alphanumeric, `TinyAsciiStr` is the edge performance library.
+
+## Examples
+
+```rust
+use tinystr::TinyAsciiStr;
+
+let s1: TinyAsciiStr<4> = "tEsT".parse().expect("Failed to parse.");
+
+assert_eq!(s1, "tEsT");
+assert_eq!(s1.to_ascii_uppercase(), "TEST");
+assert_eq!(s1.to_ascii_lowercase(), "test");
+assert_eq!(s1.to_ascii_titlecase(), "Test");
+assert!(s1.is_ascii_alphanumeric());
+assert!(!s1.is_ascii_numeric());
+
+let s2 = TinyAsciiStr::<8>::try_from_raw(*b"New York")
+ .expect("Failed to parse.");
+
+assert_eq!(s2, "New York");
+assert_eq!(s2.to_ascii_uppercase(), "NEW YORK");
+assert_eq!(s2.to_ascii_lowercase(), "new york");
+assert_eq!(s2.to_ascii_titlecase(), "New york");
+assert!(!s2.is_ascii_alphanumeric());
+```
+
+## Details
+
+When strings are of size 8 or smaller, the struct transforms the strings as `u32`/`u64` and uses
+bitmasking to provide basic string manipulation operations:
+* `is_ascii_numeric`
+* `is_ascii_alphabetic`
+* `is_ascii_alphanumeric`
+* `to_ascii_lowercase`
+* `to_ascii_uppercase`
+* `to_ascii_titlecase`
+* `PartialEq`
+
+`TinyAsciiStr` will fall back to `u8` character manipulation for strings of length greater than 8.
+
+[`ICU4X`]: ../icu/index.html
+
+<!-- cargo-rdme end -->
+
+## More Information
+
+For more information on development, authorship, contributing etc. please visit [`ICU4X home page`](https://github.com/unicode-org/icu4x).
diff --git a/crates/tinystr/benches/common/mod.rs b/crates/tinystr/benches/common/mod.rs
new file mode 100644
index 0000000..84090b6
--- /dev/null
+++ b/crates/tinystr/benches/common/mod.rs
@@ -0,0 +1,55 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+// This file was adapted from parts of https://github.com/zbraniecki/tinystr
+
+pub static STRINGS_4: &[&str] = &[
+ "US", "GB", "AR", "Hans", "CN", "AT", "PL", "FR", "AT", "Cyrl", "SR", "NO", "FR", "MK", "UK",
+];
+
+pub static STRINGS_8: &[&str] = &[
+ "Latn", "windows", "AR", "Hans", "macos", "AT", "pl", "FR", "en", "Cyrl", "SR", "NO", "419",
+ "und", "UK",
+];
+
+pub static STRINGS_16: &[&str] = &[
+ "Latn",
+ "windows",
+ "AR",
+ "Hans",
+ "macos",
+ "AT",
+ "infiniband",
+ "FR",
+ "en",
+ "Cyrl",
+ "FromIntegral",
+ "NO",
+ "419",
+ "MacintoshOSX2019",
+ "UK",
+];
+
+#[macro_export]
+macro_rules! bench_block {
+ ($c:expr, $name:expr, $action:ident) => {
+ let mut group4 = $c.benchmark_group(&format!("{}/4", $name));
+ group4.bench_function("String", $action!(String, STRINGS_4));
+ group4.bench_function("TinyAsciiStr<4>", $action!(TinyAsciiStr<4>, STRINGS_4));
+ group4.bench_function("TinyAsciiStr<8>", $action!(TinyAsciiStr<8>, STRINGS_4));
+ group4.bench_function("TinyAsciiStr<16>", $action!(TinyAsciiStr<16>, STRINGS_4));
+ group4.finish();
+
+ let mut group8 = $c.benchmark_group(&format!("{}/8", $name));
+ group8.bench_function("String", $action!(String, STRINGS_8));
+ group8.bench_function("TinyAsciiStr<8>", $action!(TinyAsciiStr<8>, STRINGS_8));
+ group8.bench_function("TinyAsciiStr<16>", $action!(TinyAsciiStr<16>, STRINGS_8));
+ group8.finish();
+
+ let mut group16 = $c.benchmark_group(&format!("{}/16", $name));
+ group16.bench_function("String", $action!(String, STRINGS_16));
+ group16.bench_function("TinyAsciiStr<16>", $action!(TinyAsciiStr<16>, STRINGS_16));
+ group16.finish();
+ };
+}
diff --git a/crates/tinystr/benches/construct.rs b/crates/tinystr/benches/construct.rs
new file mode 100644
index 0000000..0918029
--- /dev/null
+++ b/crates/tinystr/benches/construct.rs
@@ -0,0 +1,65 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+// This file was adapted from https://github.com/zbraniecki/tinystr
+
+mod common;
+use common::*;
+
+use criterion::black_box;
+use criterion::criterion_group;
+use criterion::criterion_main;
+use criterion::Bencher;
+use criterion::Criterion;
+
+use tinystr::TinyAsciiStr;
+
+fn construct_from_str(c: &mut Criterion) {
+ macro_rules! cfs {
+ ($r:ty, $inputs:expr) => {
+ |b: &mut Bencher| {
+ b.iter(|| {
+ for s in $inputs {
+ let _: $r = black_box(s.parse().unwrap());
+ }
+ })
+ }
+ };
+ }
+
+ bench_block!(c, "construct_from_str", cfs);
+}
+
+fn construct_from_utf8(c: &mut Criterion) {
+ macro_rules! cfu {
+ ($r:ty, $inputs:expr) => {
+ |b| {
+ let raw: Vec<&[u8]> = $inputs.iter().map(|s| s.as_bytes()).collect();
+ b.iter(move || {
+ for u in &raw {
+ let _ = black_box(<$r>::try_from_utf8(*u).unwrap());
+ }
+ })
+ }
+ };
+ }
+
+ let mut group4 = c.benchmark_group("construct_from_utf8/4");
+ group4.bench_function("TinyAsciiStr<4>", cfu!(TinyAsciiStr<4>, STRINGS_4));
+ group4.bench_function("TinyAsciiStr<8>", cfu!(TinyAsciiStr<8>, STRINGS_4));
+ group4.bench_function("TinyAsciiStr<16>", cfu!(TinyAsciiStr<16>, STRINGS_4));
+ group4.finish();
+
+ let mut group8 = c.benchmark_group("construct_from_utf8/8");
+ group8.bench_function("TinyAsciiStr<8>", cfu!(TinyAsciiStr<8>, STRINGS_8));
+ group8.bench_function("TinyAsciiStr<16>", cfu!(TinyAsciiStr<16>, STRINGS_8));
+ group8.finish();
+
+ let mut group16 = c.benchmark_group("construct_from_utf8/16");
+ group16.bench_function("TinyAsciiStr<16>", cfu!(TinyAsciiStr<16>, STRINGS_16));
+ group16.finish();
+}
+
+criterion_group!(benches, construct_from_str, construct_from_utf8,);
+criterion_main!(benches);
diff --git a/crates/tinystr/benches/overview.rs b/crates/tinystr/benches/overview.rs
new file mode 100644
index 0000000..474ff4b
--- /dev/null
+++ b/crates/tinystr/benches/overview.rs
@@ -0,0 +1,129 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+mod common;
+use common::*;
+
+use criterion::black_box;
+use criterion::criterion_group;
+use criterion::criterion_main;
+use criterion::Criterion;
+
+use tinystr::TinyAsciiStr;
+
+fn overview(c: &mut Criterion) {
+ let mut g = c.benchmark_group("overview");
+
+ g.bench_function("construct/utf8/TinyAsciiStr", |b| {
+ b.iter(|| {
+ for s in STRINGS_4 {
+ let _: TinyAsciiStr<4> =
+ TinyAsciiStr::try_from_utf8(black_box(s.as_bytes())).unwrap();
+ let _: TinyAsciiStr<8> =
+ TinyAsciiStr::try_from_utf8(black_box(s.as_bytes())).unwrap();
+ let _: TinyAsciiStr<16> =
+ TinyAsciiStr::try_from_utf8(black_box(s.as_bytes())).unwrap();
+ }
+ for s in STRINGS_8 {
+ let _: TinyAsciiStr<8> =
+ TinyAsciiStr::try_from_utf8(black_box(s.as_bytes())).unwrap();
+ let _: TinyAsciiStr<16> =
+ TinyAsciiStr::try_from_utf8(black_box(s.as_bytes())).unwrap();
+ }
+ for s in STRINGS_16 {
+ let _: TinyAsciiStr<16> =
+ TinyAsciiStr::try_from_utf8(black_box(s.as_bytes())).unwrap();
+ }
+ });
+ });
+
+ let strings_4_utf16: Vec<Vec<u16>> = STRINGS_4
+ .iter()
+ .map(|s| s.encode_utf16().collect())
+ .collect();
+
+ let strings_8_utf16: Vec<Vec<u16>> = STRINGS_8
+ .iter()
+ .map(|s| s.encode_utf16().collect())
+ .collect();
+
+ let strings_16_utf16: Vec<Vec<u16>> = STRINGS_16
+ .iter()
+ .map(|s| s.encode_utf16().collect())
+ .collect();
+
+ g.bench_function("construct/utf16/TinyAsciiStr", |b| {
+ b.iter(|| {
+ for s in strings_4_utf16.iter() {
+ let _: TinyAsciiStr<4> = TinyAsciiStr::try_from_utf16(black_box(s)).unwrap();
+ let _: TinyAsciiStr<8> = TinyAsciiStr::try_from_utf16(black_box(s)).unwrap();
+ let _: TinyAsciiStr<16> = TinyAsciiStr::try_from_utf16(black_box(s)).unwrap();
+ }
+ for s in strings_8_utf16.iter() {
+ let _: TinyAsciiStr<8> = TinyAsciiStr::try_from_utf16(black_box(s)).unwrap();
+ let _: TinyAsciiStr<16> = TinyAsciiStr::try_from_utf16(black_box(s)).unwrap();
+ }
+ for s in strings_16_utf16.iter() {
+ let _: TinyAsciiStr<16> = TinyAsciiStr::try_from_utf16(black_box(s)).unwrap();
+ }
+ });
+ });
+
+ let parsed_ascii_4: Vec<TinyAsciiStr<4>> = STRINGS_4
+ .iter()
+ .map(|s| s.parse::<TinyAsciiStr<4>>().unwrap())
+ .collect();
+ let parsed_ascii_8: Vec<TinyAsciiStr<8>> = STRINGS_4
+ .iter()
+ .chain(STRINGS_8)
+ .map(|s| s.parse::<TinyAsciiStr<8>>().unwrap())
+ .collect();
+ let parsed_ascii_16: Vec<TinyAsciiStr<16>> = STRINGS_4
+ .iter()
+ .chain(STRINGS_8)
+ .chain(STRINGS_16)
+ .map(|s| s.parse::<TinyAsciiStr<16>>().unwrap())
+ .collect();
+
+ g.bench_function("read/TinyAsciiStr", |b| {
+ b.iter(|| {
+ let mut collector: usize = 0;
+ for t in black_box(&parsed_ascii_4) {
+ let s: &str = t;
+ collector += s.bytes().map(usize::from).sum::<usize>();
+ }
+ for t in black_box(&parsed_ascii_8) {
+ let s: &str = t;
+ collector += s.bytes().map(usize::from).sum::<usize>();
+ }
+ for t in black_box(&parsed_ascii_16) {
+ let s: &str = t;
+ collector += s.bytes().map(usize::from).sum::<usize>();
+ }
+ collector
+ });
+ });
+
+ g.bench_function("compare/TinyAsciiStr", |b| {
+ b.iter(|| {
+ let mut collector: usize = 0;
+ for ts in black_box(&parsed_ascii_4).windows(2) {
+ let o = ts[0].cmp(&ts[1]);
+ collector ^= o as usize;
+ }
+ for ts in black_box(&parsed_ascii_8).windows(2) {
+ let o = ts[0].cmp(&ts[1]);
+ collector ^= o as usize;
+ }
+ for ts in black_box(&parsed_ascii_16).windows(2) {
+ let o = ts[0].cmp(&ts[1]);
+ collector ^= o as usize;
+ }
+ collector
+ });
+ });
+}
+
+criterion_group!(benches, overview,);
+criterion_main!(benches);
diff --git a/crates/tinystr/benches/read.rs b/crates/tinystr/benches/read.rs
new file mode 100644
index 0000000..793bb14
--- /dev/null
+++ b/crates/tinystr/benches/read.rs
@@ -0,0 +1,34 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+mod common;
+use common::*;
+
+use criterion::black_box;
+use criterion::criterion_group;
+use criterion::criterion_main;
+use criterion::Bencher;
+use criterion::Criterion;
+
+use tinystr::TinyAsciiStr;
+
+fn read(c: &mut Criterion) {
+ macro_rules! cfs {
+ ($r:ty, $inputs:expr) => {
+ |b: &mut Bencher| {
+ let parsed: Vec<$r> = $inputs.iter().map(|s| s.parse().unwrap()).collect();
+ b.iter(|| {
+ for s in &parsed {
+ let _: &str = black_box(&**s);
+ }
+ })
+ }
+ };
+ }
+
+ bench_block!(c, "read", cfs);
+}
+
+criterion_group!(benches, read,);
+criterion_main!(benches);
diff --git a/crates/tinystr/benches/serde.rs b/crates/tinystr/benches/serde.rs
new file mode 100644
index 0000000..b034122
--- /dev/null
+++ b/crates/tinystr/benches/serde.rs
@@ -0,0 +1,37 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+mod common;
+use common::*;
+
+use criterion::black_box;
+use criterion::criterion_group;
+use criterion::criterion_main;
+use criterion::Bencher;
+use criterion::Criterion;
+
+use tinystr::TinyAsciiStr;
+
+fn deserialize(c: &mut Criterion) {
+ macro_rules! cfs {
+ ($r:ty, $inputs:expr) => {
+ |b: &mut Bencher| {
+ let serialized: Vec<Vec<u8>> = $inputs
+ .iter()
+ .map(|s| postcard::to_stdvec(&s.parse::<$r>().unwrap()).unwrap())
+ .collect();
+ b.iter(|| {
+ for bytes in &serialized {
+ let _: Result<$r, _> = black_box(postcard::from_bytes(bytes));
+ }
+ })
+ }
+ };
+ }
+
+ bench_block!(c, "deserialize", cfs);
+}
+
+criterion_group!(benches, deserialize,);
+criterion_main!(benches);
diff --git a/crates/tinystr/cargo_embargo.json b/crates/tinystr/cargo_embargo.json
new file mode 100644
index 0000000..87dbb38
--- /dev/null
+++ b/crates/tinystr/cargo_embargo.json
@@ -0,0 +1,3 @@
+{
+ "features": ["zerovec"]
+}
\ No newline at end of file
diff --git a/crates/tinystr/src/ascii.rs b/crates/tinystr/src/ascii.rs
new file mode 100644
index 0000000..9b0e24e
--- /dev/null
+++ b/crates/tinystr/src/ascii.rs
@@ -0,0 +1,1167 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use crate::asciibyte::AsciiByte;
+use crate::int_ops::{Aligned4, Aligned8};
+use crate::ParseError;
+use core::fmt;
+use core::ops::Deref;
+use core::str::{self, FromStr};
+
+#[repr(transparent)]
+#[derive(PartialEq, Eq, Ord, PartialOrd, Copy, Clone, Hash)]
+pub struct TinyAsciiStr<const N: usize> {
+ bytes: [AsciiByte; N],
+}
+
+impl<const N: usize> TinyAsciiStr<N> {
+ #[inline]
+ pub const fn try_from_str(s: &str) -> Result<Self, ParseError> {
+ Self::try_from_utf8(s.as_bytes())
+ }
+
+ /// Creates a `TinyAsciiStr<N>` from the given UTF-8 slice.
+ /// `code_units` may contain at most `N` non-null ASCII code points.
+ #[inline]
+ pub const fn try_from_utf8(code_units: &[u8]) -> Result<Self, ParseError> {
+ Self::try_from_utf8_inner(code_units, false)
+ }
+
+ /// Creates a `TinyAsciiStr<N>` from the given UTF-16 slice.
+ /// `code_units` may contain at most `N` non-null ASCII code points.
+ #[inline]
+ pub const fn try_from_utf16(code_units: &[u16]) -> Result<Self, ParseError> {
+ Self::try_from_utf16_inner(code_units, 0, code_units.len(), false)
+ }
+
+ /// Creates a `TinyAsciiStr<N>` from a UTF-8 slice, replacing invalid code units.
+ ///
+ /// Invalid code units, as well as null or non-ASCII code points
+ /// (i.e. those outside the range U+0001..=U+007F`)
+ /// will be replaced with the replacement byte.
+ ///
+ /// The input slice will be truncated if its length exceeds `N`.
+ pub const fn from_utf8_lossy(code_units: &[u8], replacement: u8) -> Self {
+ let mut out = [0; N];
+ let mut i = 0;
+ // Ord is not available in const, so no `.min(N)`
+ let len = if code_units.len() > N {
+ N
+ } else {
+ code_units.len()
+ };
+
+ // Indexing is protected by the len check above
+ #[allow(clippy::indexing_slicing)]
+ while i < len {
+ let b = code_units[i];
+ if b > 0 && b < 0x80 {
+ out[i] = b;
+ } else {
+ out[i] = replacement;
+ }
+ i += 1;
+ }
+
+ Self {
+ // SAFETY: `out` only contains ASCII bytes and has same size as `self.bytes`
+ bytes: unsafe { AsciiByte::to_ascii_byte_array(&out) },
+ }
+ }
+
+ /// Creates a `TinyAsciiStr<N>` from a UTF-16 slice, replacing invalid code units.
+ ///
+ /// Invalid code units, as well as null or non-ASCII code points
+ /// (i.e. those outside the range U+0001..=U+007F`)
+ /// will be replaced with the replacement byte.
+ ///
+ /// The input slice will be truncated if its length exceeds `N`.
+ pub const fn from_utf16_lossy(code_units: &[u16], replacement: u8) -> Self {
+ let mut out = [0; N];
+ let mut i = 0;
+ // Ord is not available in const, so no `.min(N)`
+ let len = if code_units.len() > N {
+ N
+ } else {
+ code_units.len()
+ };
+
+ // Indexing is protected by the len check above
+ #[allow(clippy::indexing_slicing)]
+ while i < len {
+ let b = code_units[i];
+ if b > 0 && b < 0x80 {
+ out[i] = b as u8;
+ } else {
+ out[i] = replacement;
+ }
+ i += 1;
+ }
+
+ Self {
+ // SAFETY: `out` only contains ASCII bytes and has same size as `self.bytes`
+ bytes: unsafe { AsciiByte::to_ascii_byte_array(&out) },
+ }
+ }
+
+ /// Attempts to parse a fixed-length byte array to a `TinyAsciiStr`.
+ ///
+ /// The byte array may contain trailing NUL bytes.
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// use tinystr::tinystr;
+ /// use tinystr::TinyAsciiStr;
+ ///
+ /// assert_eq!(
+ /// TinyAsciiStr::<3>::try_from_raw(*b"GB\0"),
+ /// Ok(tinystr!(3, "GB"))
+ /// );
+ /// assert_eq!(
+ /// TinyAsciiStr::<3>::try_from_raw(*b"USD"),
+ /// Ok(tinystr!(3, "USD"))
+ /// );
+ /// assert!(matches!(TinyAsciiStr::<3>::try_from_raw(*b"\0A\0"), Err(_)));
+ /// ```
+ pub const fn try_from_raw(raw: [u8; N]) -> Result<Self, ParseError> {
+ Self::try_from_utf8_inner(&raw, true)
+ }
+
+ pub(crate) const fn try_from_utf8_inner(
+ code_units: &[u8],
+ allow_trailing_null: bool,
+ ) -> Result<Self, ParseError> {
+ if code_units.len() > N {
+ return Err(ParseError::TooLong {
+ max: N,
+ len: code_units.len(),
+ });
+ }
+
+ let mut out = [0; N];
+ let mut i = 0;
+ let mut found_null = false;
+ // Indexing is protected by TinyStrError::TooLarge
+ #[allow(clippy::indexing_slicing)]
+ while i < code_units.len() {
+ let b = code_units[i];
+
+ if b == 0 {
+ found_null = true;
+ } else if b >= 0x80 {
+ return Err(ParseError::NonAscii);
+ } else if found_null {
+ // Error if there are contentful bytes after null
+ return Err(ParseError::ContainsNull);
+ }
+ out[i] = b;
+
+ i += 1;
+ }
+
+ if !allow_trailing_null && found_null {
+ // We found some trailing nulls, error
+ return Err(ParseError::ContainsNull);
+ }
+
+ Ok(Self {
+ // SAFETY: `out` only contains ASCII bytes and has same size as `self.bytes`
+ bytes: unsafe { AsciiByte::to_ascii_byte_array(&out) },
+ })
+ }
+
+ pub(crate) const fn try_from_utf16_inner(
+ code_units: &[u16],
+ start: usize,
+ end: usize,
+ allow_trailing_null: bool,
+ ) -> Result<Self, ParseError> {
+ let len = end - start;
+ if len > N {
+ return Err(ParseError::TooLong { max: N, len });
+ }
+
+ let mut out = [0; N];
+ let mut i = 0;
+ let mut found_null = false;
+ // Indexing is protected by TinyStrError::TooLarge
+ #[allow(clippy::indexing_slicing)]
+ while i < len {
+ let b = code_units[start + i];
+
+ if b == 0 {
+ found_null = true;
+ } else if b >= 0x80 {
+ return Err(ParseError::NonAscii);
+ } else if found_null {
+ // Error if there are contentful bytes after null
+ return Err(ParseError::ContainsNull);
+ }
+ out[i] = b as u8;
+
+ i += 1;
+ }
+
+ if !allow_trailing_null && found_null {
+ // We found some trailing nulls, error
+ return Err(ParseError::ContainsNull);
+ }
+
+ Ok(Self {
+ // SAFETY: `out` only contains ASCII bytes and has same size as `self.bytes`
+ bytes: unsafe { AsciiByte::to_ascii_byte_array(&out) },
+ })
+ }
+
+ #[inline]
+ pub const fn as_str(&self) -> &str {
+ // as_utf8 is valid utf8
+ unsafe { str::from_utf8_unchecked(self.as_utf8()) }
+ }
+
+ #[inline]
+ #[must_use]
+ pub const fn len(&self) -> usize {
+ if N <= 4 {
+ Aligned4::from_ascii_bytes(&self.bytes).len()
+ } else if N <= 8 {
+ Aligned8::from_ascii_bytes(&self.bytes).len()
+ } else {
+ let mut i = 0;
+ #[allow(clippy::indexing_slicing)] // < N is safe
+ while i < N && self.bytes[i] as u8 != AsciiByte::B0 as u8 {
+ i += 1
+ }
+ i
+ }
+ }
+
+ #[inline]
+ #[must_use]
+ pub const fn is_empty(&self) -> bool {
+ self.bytes[0] as u8 == AsciiByte::B0 as u8
+ }
+
+ #[inline]
+ #[must_use]
+ pub const fn as_utf8(&self) -> &[u8] {
+ // Safe because `self.bytes.as_slice()` pointer-casts to `&[u8]`,
+ // and changing the length of that slice to self.len() < N is safe.
+ unsafe {
+ core::slice::from_raw_parts(self.bytes.as_slice().as_ptr() as *const u8, self.len())
+ }
+ }
+
+ #[inline]
+ #[must_use]
+ pub const fn all_bytes(&self) -> &[u8; N] {
+ // SAFETY: `self.bytes` has same size as [u8; N]
+ unsafe { &*(self.bytes.as_ptr() as *const [u8; N]) }
+ }
+
+ #[inline]
+ #[must_use]
+ /// Resizes a `TinyAsciiStr<N>` to a `TinyAsciiStr<M>`.
+ ///
+ /// If `M < len()` the string gets truncated, otherwise only the
+ /// memory representation changes.
+ pub const fn resize<const M: usize>(self) -> TinyAsciiStr<M> {
+ let mut bytes = [0; M];
+ let mut i = 0;
+ // Indexing is protected by the loop guard
+ #[allow(clippy::indexing_slicing)]
+ while i < M && i < N {
+ bytes[i] = self.bytes[i] as u8;
+ i += 1;
+ }
+ // `self.bytes` only contains ASCII bytes, with no null bytes between
+ // ASCII characters, so this also holds for `bytes`.
+ unsafe { TinyAsciiStr::from_utf8_unchecked(bytes) }
+ }
+
+ #[inline]
+ #[must_use]
+ /// Returns a `TinyAsciiStr<Q>` with the concatenation of this string,
+ /// `TinyAsciiStr<N>`, and another string, `TinyAsciiStr<M>`.
+ ///
+ /// If `Q < N + M`, the string gets truncated.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use tinystr::tinystr;
+ /// use tinystr::TinyAsciiStr;
+ ///
+ /// let abc = tinystr!(6, "abc");
+ /// let defg = tinystr!(6, "defg");
+ ///
+ /// // The concatenation is successful if Q is large enough...
+ /// assert_eq!(abc.concat(defg), tinystr!(16, "abcdefg"));
+ /// assert_eq!(abc.concat(defg), tinystr!(12, "abcdefg"));
+ /// assert_eq!(abc.concat(defg), tinystr!(8, "abcdefg"));
+ /// assert_eq!(abc.concat(defg), tinystr!(7, "abcdefg"));
+ ///
+ /// /// ...but it truncates of Q is too small.
+ /// assert_eq!(abc.concat(defg), tinystr!(6, "abcdef"));
+ /// assert_eq!(abc.concat(defg), tinystr!(2, "ab"));
+ /// ```
+ pub const fn concat<const M: usize, const Q: usize>(
+ self,
+ other: TinyAsciiStr<M>,
+ ) -> TinyAsciiStr<Q> {
+ let mut result = self.resize::<Q>();
+ let mut i = self.len();
+ let mut j = 0;
+ // Indexing is protected by the loop guard
+ #[allow(clippy::indexing_slicing)]
+ while i < Q && j < M {
+ result.bytes[i] = other.bytes[j];
+ i += 1;
+ j += 1;
+ }
+ result
+ }
+
+ /// # Safety
+ /// Must be called with a bytes array made of valid ASCII bytes, with no null bytes
+ /// between ASCII characters
+ #[must_use]
+ pub const unsafe fn from_utf8_unchecked(code_units: [u8; N]) -> Self {
+ Self {
+ bytes: AsciiByte::to_ascii_byte_array(&code_units),
+ }
+ }
+}
+
+macro_rules! check_is {
+ ($self:ident, $check_int:ident, $check_u8:ident) => {
+ if N <= 4 {
+ Aligned4::from_ascii_bytes(&$self.bytes).$check_int()
+ } else if N <= 8 {
+ Aligned8::from_ascii_bytes(&$self.bytes).$check_int()
+ } else {
+ let mut i = 0;
+ // Won't panic because self.bytes has length N
+ #[allow(clippy::indexing_slicing)]
+ while i < N && $self.bytes[i] as u8 != AsciiByte::B0 as u8 {
+ if !($self.bytes[i] as u8).$check_u8() {
+ return false;
+ }
+ i += 1;
+ }
+ true
+ }
+ };
+ ($self:ident, $check_int:ident, !$check_u8_0_inv:ident, !$check_u8_1_inv:ident) => {
+ if N <= 4 {
+ Aligned4::from_ascii_bytes(&$self.bytes).$check_int()
+ } else if N <= 8 {
+ Aligned8::from_ascii_bytes(&$self.bytes).$check_int()
+ } else {
+ // Won't panic because N is > 8
+ if ($self.bytes[0] as u8).$check_u8_0_inv() {
+ return false;
+ }
+ let mut i = 1;
+ // Won't panic because self.bytes has length N
+ #[allow(clippy::indexing_slicing)]
+ while i < N && $self.bytes[i] as u8 != AsciiByte::B0 as u8 {
+ if ($self.bytes[i] as u8).$check_u8_1_inv() {
+ return false;
+ }
+ i += 1;
+ }
+ true
+ }
+ };
+ ($self:ident, $check_int:ident, $check_u8_0_inv:ident, $check_u8_1_inv:ident) => {
+ if N <= 4 {
+ Aligned4::from_ascii_bytes(&$self.bytes).$check_int()
+ } else if N <= 8 {
+ Aligned8::from_ascii_bytes(&$self.bytes).$check_int()
+ } else {
+ // Won't panic because N is > 8
+ if !($self.bytes[0] as u8).$check_u8_0_inv() {
+ return false;
+ }
+ let mut i = 1;
+ // Won't panic because self.bytes has length N
+ #[allow(clippy::indexing_slicing)]
+ while i < N && $self.bytes[i] as u8 != AsciiByte::B0 as u8 {
+ if !($self.bytes[i] as u8).$check_u8_1_inv() {
+ return false;
+ }
+ i += 1;
+ }
+ true
+ }
+ };
+}
+
+impl<const N: usize> TinyAsciiStr<N> {
+ /// Checks if the value is composed of ASCII alphabetic characters:
+ ///
+ /// * U+0041 'A' ..= U+005A 'Z', or
+ /// * U+0061 'a' ..= U+007A 'z'.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use tinystr::TinyAsciiStr;
+ ///
+ /// let s1: TinyAsciiStr<4> = "Test".parse().expect("Failed to parse.");
+ /// let s2: TinyAsciiStr<4> = "Te3t".parse().expect("Failed to parse.");
+ ///
+ /// assert!(s1.is_ascii_alphabetic());
+ /// assert!(!s2.is_ascii_alphabetic());
+ /// ```
+ #[inline]
+ #[must_use]
+ pub const fn is_ascii_alphabetic(&self) -> bool {
+ check_is!(self, is_ascii_alphabetic, is_ascii_alphabetic)
+ }
+
+ /// Checks if the value is composed of ASCII alphanumeric characters:
+ ///
+ /// * U+0041 'A' ..= U+005A 'Z', or
+ /// * U+0061 'a' ..= U+007A 'z', or
+ /// * U+0030 '0' ..= U+0039 '9'.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use tinystr::TinyAsciiStr;
+ ///
+ /// let s1: TinyAsciiStr<4> = "A15b".parse().expect("Failed to parse.");
+ /// let s2: TinyAsciiStr<4> = "[3@w".parse().expect("Failed to parse.");
+ ///
+ /// assert!(s1.is_ascii_alphanumeric());
+ /// assert!(!s2.is_ascii_alphanumeric());
+ /// ```
+ #[inline]
+ #[must_use]
+ pub const fn is_ascii_alphanumeric(&self) -> bool {
+ check_is!(self, is_ascii_alphanumeric, is_ascii_alphanumeric)
+ }
+
+ /// Checks if the value is composed of ASCII decimal digits:
+ ///
+ /// * U+0030 '0' ..= U+0039 '9'.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use tinystr::TinyAsciiStr;
+ ///
+ /// let s1: TinyAsciiStr<4> = "312".parse().expect("Failed to parse.");
+ /// let s2: TinyAsciiStr<4> = "3d".parse().expect("Failed to parse.");
+ ///
+ /// assert!(s1.is_ascii_numeric());
+ /// assert!(!s2.is_ascii_numeric());
+ /// ```
+ #[inline]
+ #[must_use]
+ pub const fn is_ascii_numeric(&self) -> bool {
+ check_is!(self, is_ascii_numeric, is_ascii_digit)
+ }
+
+ /// Checks if the value is in ASCII lower case.
+ ///
+ /// All letter characters are checked for case. Non-letter characters are ignored.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use tinystr::TinyAsciiStr;
+ ///
+ /// let s1: TinyAsciiStr<4> = "teSt".parse().expect("Failed to parse.");
+ /// let s2: TinyAsciiStr<4> = "test".parse().expect("Failed to parse.");
+ /// let s3: TinyAsciiStr<4> = "001z".parse().expect("Failed to parse.");
+ ///
+ /// assert!(!s1.is_ascii_lowercase());
+ /// assert!(s2.is_ascii_lowercase());
+ /// assert!(s3.is_ascii_lowercase());
+ /// ```
+ #[inline]
+ #[must_use]
+ pub const fn is_ascii_lowercase(&self) -> bool {
+ check_is!(
+ self,
+ is_ascii_lowercase,
+ !is_ascii_uppercase,
+ !is_ascii_uppercase
+ )
+ }
+
+ /// Checks if the value is in ASCII title case.
+ ///
+ /// This verifies that the first character is ASCII uppercase and all others ASCII lowercase.
+ /// Non-letter characters are ignored.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use tinystr::TinyAsciiStr;
+ ///
+ /// let s1: TinyAsciiStr<4> = "teSt".parse().expect("Failed to parse.");
+ /// let s2: TinyAsciiStr<4> = "Test".parse().expect("Failed to parse.");
+ /// let s3: TinyAsciiStr<4> = "001z".parse().expect("Failed to parse.");
+ ///
+ /// assert!(!s1.is_ascii_titlecase());
+ /// assert!(s2.is_ascii_titlecase());
+ /// assert!(s3.is_ascii_titlecase());
+ /// ```
+ #[inline]
+ #[must_use]
+ pub const fn is_ascii_titlecase(&self) -> bool {
+ check_is!(
+ self,
+ is_ascii_titlecase,
+ !is_ascii_lowercase,
+ !is_ascii_uppercase
+ )
+ }
+
+ /// Checks if the value is in ASCII upper case.
+ ///
+ /// All letter characters are checked for case. Non-letter characters are ignored.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use tinystr::TinyAsciiStr;
+ ///
+ /// let s1: TinyAsciiStr<4> = "teSt".parse().expect("Failed to parse.");
+ /// let s2: TinyAsciiStr<4> = "TEST".parse().expect("Failed to parse.");
+ /// let s3: TinyAsciiStr<4> = "001z".parse().expect("Failed to parse.");
+ ///
+ /// assert!(!s1.is_ascii_uppercase());
+ /// assert!(s2.is_ascii_uppercase());
+ /// assert!(!s3.is_ascii_uppercase());
+ /// ```
+ #[inline]
+ #[must_use]
+ pub const fn is_ascii_uppercase(&self) -> bool {
+ check_is!(
+ self,
+ is_ascii_uppercase,
+ !is_ascii_lowercase,
+ !is_ascii_lowercase
+ )
+ }
+
+ /// Checks if the value is composed of ASCII alphabetic lower case characters:
+ ///
+ /// * U+0061 'a' ..= U+007A 'z',
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use tinystr::TinyAsciiStr;
+ ///
+ /// let s1: TinyAsciiStr<4> = "Test".parse().expect("Failed to parse.");
+ /// let s2: TinyAsciiStr<4> = "Te3t".parse().expect("Failed to parse.");
+ /// let s3: TinyAsciiStr<4> = "teSt".parse().expect("Failed to parse.");
+ /// let s4: TinyAsciiStr<4> = "test".parse().expect("Failed to parse.");
+ /// let s5: TinyAsciiStr<4> = "001z".parse().expect("Failed to parse.");
+ ///
+ /// assert!(!s1.is_ascii_alphabetic_lowercase());
+ /// assert!(!s2.is_ascii_alphabetic_lowercase());
+ /// assert!(!s3.is_ascii_alphabetic_lowercase());
+ /// assert!(s4.is_ascii_alphabetic_lowercase());
+ /// assert!(!s5.is_ascii_alphabetic_lowercase());
+ /// ```
+ #[inline]
+ #[must_use]
+ pub const fn is_ascii_alphabetic_lowercase(&self) -> bool {
+ check_is!(
+ self,
+ is_ascii_alphabetic_lowercase,
+ is_ascii_lowercase,
+ is_ascii_lowercase
+ )
+ }
+
+ /// Checks if the value is composed of ASCII alphabetic, with the first character being ASCII uppercase, and all others ASCII lowercase.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use tinystr::TinyAsciiStr;
+ ///
+ /// let s1: TinyAsciiStr<4> = "Test".parse().expect("Failed to parse.");
+ /// let s2: TinyAsciiStr<4> = "Te3t".parse().expect("Failed to parse.");
+ /// let s3: TinyAsciiStr<4> = "teSt".parse().expect("Failed to parse.");
+ /// let s4: TinyAsciiStr<4> = "test".parse().expect("Failed to parse.");
+ /// let s5: TinyAsciiStr<4> = "001z".parse().expect("Failed to parse.");
+ ///
+ /// assert!(s1.is_ascii_alphabetic_titlecase());
+ /// assert!(!s2.is_ascii_alphabetic_titlecase());
+ /// assert!(!s3.is_ascii_alphabetic_titlecase());
+ /// assert!(!s4.is_ascii_alphabetic_titlecase());
+ /// assert!(!s5.is_ascii_alphabetic_titlecase());
+ /// ```
+ #[inline]
+ #[must_use]
+ pub const fn is_ascii_alphabetic_titlecase(&self) -> bool {
+ check_is!(
+ self,
+ is_ascii_alphabetic_titlecase,
+ is_ascii_uppercase,
+ is_ascii_lowercase
+ )
+ }
+
+ /// Checks if the value is composed of ASCII alphabetic upper case characters:
+ ///
+ /// * U+0041 'A' ..= U+005A 'Z',
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use tinystr::TinyAsciiStr;
+ ///
+ /// let s1: TinyAsciiStr<4> = "Test".parse().expect("Failed to parse.");
+ /// let s2: TinyAsciiStr<4> = "Te3t".parse().expect("Failed to parse.");
+ /// let s3: TinyAsciiStr<4> = "teSt".parse().expect("Failed to parse.");
+ /// let s4: TinyAsciiStr<4> = "TEST".parse().expect("Failed to parse.");
+ /// let s5: TinyAsciiStr<4> = "001z".parse().expect("Failed to parse.");
+ ///
+ /// assert!(!s1.is_ascii_alphabetic_uppercase());
+ /// assert!(!s2.is_ascii_alphabetic_uppercase());
+ /// assert!(!s3.is_ascii_alphabetic_uppercase());
+ /// assert!(s4.is_ascii_alphabetic_uppercase());
+ /// assert!(!s5.is_ascii_alphabetic_uppercase());
+ /// ```
+ #[inline]
+ #[must_use]
+ pub const fn is_ascii_alphabetic_uppercase(&self) -> bool {
+ check_is!(
+ self,
+ is_ascii_alphabetic_uppercase,
+ is_ascii_uppercase,
+ is_ascii_uppercase
+ )
+ }
+}
+
+macro_rules! to {
+ ($self:ident, $to:ident, $later_char_to:ident $(,$first_char_to:ident)?) => {{
+ let mut i = 0;
+ if N <= 4 {
+ let aligned = Aligned4::from_ascii_bytes(&$self.bytes).$to().to_ascii_bytes();
+ // Won't panic because self.bytes has length N and aligned has length >= N
+ #[allow(clippy::indexing_slicing)]
+ while i < N {
+ $self.bytes[i] = aligned[i];
+ i += 1;
+ }
+ } else if N <= 8 {
+ let aligned = Aligned8::from_ascii_bytes(&$self.bytes).$to().to_ascii_bytes();
+ // Won't panic because self.bytes has length N and aligned has length >= N
+ #[allow(clippy::indexing_slicing)]
+ while i < N {
+ $self.bytes[i] = aligned[i];
+ i += 1;
+ }
+ } else {
+ // Won't panic because self.bytes has length N
+ #[allow(clippy::indexing_slicing)]
+ while i < N && $self.bytes[i] as u8 != AsciiByte::B0 as u8 {
+ // SAFETY: AsciiByte is repr(u8) and has same size as u8
+ unsafe {
+ $self.bytes[i] = core::mem::transmute::<u8, AsciiByte>(
+ ($self.bytes[i] as u8).$later_char_to()
+ );
+ }
+ i += 1;
+ }
+ // SAFETY: AsciiByte is repr(u8) and has same size as u8
+ $(
+ $self.bytes[0] = unsafe {
+ core::mem::transmute::<u8, AsciiByte>(($self.bytes[0] as u8).$first_char_to())
+ };
+ )?
+ }
+ $self
+ }};
+}
+
+impl<const N: usize> TinyAsciiStr<N> {
+ /// Converts this type to its ASCII lower case equivalent in-place.
+ ///
+ /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z', other characters are unchanged.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use tinystr::TinyAsciiStr;
+ ///
+ /// let s1: TinyAsciiStr<4> = "TeS3".parse().expect("Failed to parse.");
+ ///
+ /// assert_eq!(&*s1.to_ascii_lowercase(), "tes3");
+ /// ```
+ #[inline]
+ #[must_use]
+ pub const fn to_ascii_lowercase(mut self) -> Self {
+ to!(self, to_ascii_lowercase, to_ascii_lowercase)
+ }
+
+ /// Converts this type to its ASCII title case equivalent in-place.
+ ///
+ /// The first character is converted to ASCII uppercase; the remaining characters
+ /// are converted to ASCII lowercase.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use tinystr::TinyAsciiStr;
+ ///
+ /// let s1: TinyAsciiStr<4> = "teSt".parse().expect("Failed to parse.");
+ ///
+ /// assert_eq!(&*s1.to_ascii_titlecase(), "Test");
+ /// ```
+ #[inline]
+ #[must_use]
+ pub const fn to_ascii_titlecase(mut self) -> Self {
+ to!(
+ self,
+ to_ascii_titlecase,
+ to_ascii_lowercase,
+ to_ascii_uppercase
+ )
+ }
+
+ /// Converts this type to its ASCII upper case equivalent in-place.
+ ///
+ /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z', other characters are unchanged.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use tinystr::TinyAsciiStr;
+ ///
+ /// let s1: TinyAsciiStr<4> = "Tes3".parse().expect("Failed to parse.");
+ ///
+ /// assert_eq!(&*s1.to_ascii_uppercase(), "TES3");
+ /// ```
+ #[inline]
+ #[must_use]
+ pub const fn to_ascii_uppercase(mut self) -> Self {
+ to!(self, to_ascii_uppercase, to_ascii_uppercase)
+ }
+}
+
+impl<const N: usize> fmt::Debug for TinyAsciiStr<N> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::Debug::fmt(self.as_str(), f)
+ }
+}
+
+impl<const N: usize> fmt::Display for TinyAsciiStr<N> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::Display::fmt(self.as_str(), f)
+ }
+}
+
+impl<const N: usize> Deref for TinyAsciiStr<N> {
+ type Target = str;
+ #[inline]
+ fn deref(&self) -> &str {
+ self.as_str()
+ }
+}
+
+impl<const N: usize> FromStr for TinyAsciiStr<N> {
+ type Err = ParseError;
+ #[inline]
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
+ Self::try_from_str(s)
+ }
+}
+
+impl<const N: usize> PartialEq<str> for TinyAsciiStr<N> {
+ fn eq(&self, other: &str) -> bool {
+ self.deref() == other
+ }
+}
+
+impl<const N: usize> PartialEq<&str> for TinyAsciiStr<N> {
+ fn eq(&self, other: &&str) -> bool {
+ self.deref() == *other
+ }
+}
+
+#[cfg(feature = "alloc")]
+impl<const N: usize> PartialEq<alloc::string::String> for TinyAsciiStr<N> {
+ fn eq(&self, other: &alloc::string::String) -> bool {
+ self.deref() == other.deref()
+ }
+}
+
+#[cfg(feature = "alloc")]
+impl<const N: usize> PartialEq<TinyAsciiStr<N>> for alloc::string::String {
+ fn eq(&self, other: &TinyAsciiStr<N>) -> bool {
+ self.deref() == other.deref()
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ use rand::distributions::Distribution;
+ use rand::distributions::Standard;
+ use rand::rngs::SmallRng;
+ use rand::seq::SliceRandom;
+ use rand::SeedableRng;
+
+ const STRINGS: [&str; 26] = [
+ "Latn",
+ "laTn",
+ "windows",
+ "AR",
+ "Hans",
+ "macos",
+ "AT",
+ "infiniband",
+ "FR",
+ "en",
+ "Cyrl",
+ "FromIntegral",
+ "NO",
+ "419",
+ "MacintoshOSX2019",
+ "a3z",
+ "A3z",
+ "A3Z",
+ "a3Z",
+ "3A",
+ "3Z",
+ "3a",
+ "3z",
+ "@@[`{",
+ "UK",
+ "E12",
+ ];
+
+ fn gen_strings(num_strings: usize, allowed_lengths: &[usize]) -> Vec<String> {
+ let mut rng = SmallRng::seed_from_u64(2022);
+ // Need to do this in 2 steps since the RNG is needed twice
+ let string_lengths = core::iter::repeat_with(|| *allowed_lengths.choose(&mut rng).unwrap())
+ .take(num_strings)
+ .collect::<Vec<usize>>();
+ string_lengths
+ .iter()
+ .map(|len| {
+ Standard
+ .sample_iter(&mut rng)
+ .filter(|b: &u8| *b > 0 && *b < 0x80)
+ .take(*len)
+ .collect::<Vec<u8>>()
+ })
+ .map(|byte_vec| String::from_utf8(byte_vec).expect("All ASCII"))
+ .collect()
+ }
+
+ fn check_operation<T, F1, F2, const N: usize>(reference_f: F1, tinystr_f: F2)
+ where
+ F1: Fn(&str) -> T,
+ F2: Fn(TinyAsciiStr<N>) -> T,
+ T: core::fmt::Debug + core::cmp::PartialEq,
+ {
+ for s in STRINGS
+ .into_iter()
+ .map(str::to_owned)
+ .chain(gen_strings(100, &[3, 4, 5, 8, 12]))
+ {
+ let t = match TinyAsciiStr::<N>::from_str(&s) {
+ Ok(t) => t,
+ Err(ParseError::TooLong { .. }) => continue,
+ Err(e) => panic!("{}", e),
+ };
+ let expected = reference_f(&s);
+ let actual = tinystr_f(t);
+ assert_eq!(expected, actual, "TinyAsciiStr<{N}>: {s:?}");
+
+ let s_utf16: Vec<u16> = s.encode_utf16().collect();
+ let t = match TinyAsciiStr::<N>::try_from_utf16(&s_utf16) {
+ Ok(t) => t,
+ Err(ParseError::TooLong { .. }) => continue,
+ Err(e) => panic!("{}", e),
+ };
+ let expected = reference_f(&s);
+ let actual = tinystr_f(t);
+ assert_eq!(expected, actual, "TinyAsciiStr<{N}>: {s:?}");
+ }
+ }
+
+ #[test]
+ fn test_is_ascii_alphabetic() {
+ fn check<const N: usize>() {
+ check_operation(
+ |s| s.chars().all(|c| c.is_ascii_alphabetic()),
+ |t: TinyAsciiStr<N>| TinyAsciiStr::is_ascii_alphabetic(&t),
+ )
+ }
+ check::<2>();
+ check::<3>();
+ check::<4>();
+ check::<5>();
+ check::<8>();
+ check::<16>();
+ }
+
+ #[test]
+ fn test_is_ascii_alphanumeric() {
+ fn check<const N: usize>() {
+ check_operation(
+ |s| s.chars().all(|c| c.is_ascii_alphanumeric()),
+ |t: TinyAsciiStr<N>| TinyAsciiStr::is_ascii_alphanumeric(&t),
+ )
+ }
+ check::<2>();
+ check::<3>();
+ check::<4>();
+ check::<5>();
+ check::<8>();
+ check::<16>();
+ }
+
+ #[test]
+ fn test_is_ascii_numeric() {
+ fn check<const N: usize>() {
+ check_operation(
+ |s| s.chars().all(|c| c.is_ascii_digit()),
+ |t: TinyAsciiStr<N>| TinyAsciiStr::is_ascii_numeric(&t),
+ )
+ }
+ check::<2>();
+ check::<3>();
+ check::<4>();
+ check::<5>();
+ check::<8>();
+ check::<16>();
+ }
+
+ #[test]
+ fn test_is_ascii_lowercase() {
+ fn check<const N: usize>() {
+ check_operation(
+ |s| {
+ s == TinyAsciiStr::<16>::try_from_str(s)
+ .unwrap()
+ .to_ascii_lowercase()
+ .as_str()
+ },
+ |t: TinyAsciiStr<N>| TinyAsciiStr::is_ascii_lowercase(&t),
+ )
+ }
+ check::<2>();
+ check::<3>();
+ check::<4>();
+ check::<5>();
+ check::<8>();
+ check::<16>();
+ }
+
+ #[test]
+ fn test_is_ascii_titlecase() {
+ fn check<const N: usize>() {
+ check_operation(
+ |s| {
+ s == TinyAsciiStr::<16>::try_from_str(s)
+ .unwrap()
+ .to_ascii_titlecase()
+ .as_str()
+ },
+ |t: TinyAsciiStr<N>| TinyAsciiStr::is_ascii_titlecase(&t),
+ )
+ }
+ check::<2>();
+ check::<3>();
+ check::<4>();
+ check::<5>();
+ check::<8>();
+ check::<16>();
+ }
+
+ #[test]
+ fn test_is_ascii_uppercase() {
+ fn check<const N: usize>() {
+ check_operation(
+ |s| {
+ s == TinyAsciiStr::<16>::try_from_str(s)
+ .unwrap()
+ .to_ascii_uppercase()
+ .as_str()
+ },
+ |t: TinyAsciiStr<N>| TinyAsciiStr::is_ascii_uppercase(&t),
+ )
+ }
+ check::<2>();
+ check::<3>();
+ check::<4>();
+ check::<5>();
+ check::<8>();
+ check::<16>();
+ }
+
+ #[test]
+ fn test_is_ascii_alphabetic_lowercase() {
+ fn check<const N: usize>() {
+ check_operation(
+ |s| {
+ // Check alphabetic
+ s.chars().all(|c| c.is_ascii_alphabetic()) &&
+ // Check lowercase
+ s == TinyAsciiStr::<16>::try_from_str(s)
+ .unwrap()
+ .to_ascii_lowercase()
+ .as_str()
+ },
+ |t: TinyAsciiStr<N>| TinyAsciiStr::is_ascii_alphabetic_lowercase(&t),
+ )
+ }
+ check::<2>();
+ check::<3>();
+ check::<4>();
+ check::<5>();
+ check::<8>();
+ check::<16>();
+ }
+
+ #[test]
+ fn test_is_ascii_alphabetic_titlecase() {
+ fn check<const N: usize>() {
+ check_operation(
+ |s| {
+ // Check alphabetic
+ s.chars().all(|c| c.is_ascii_alphabetic()) &&
+ // Check titlecase
+ s == TinyAsciiStr::<16>::try_from_str(s)
+ .unwrap()
+ .to_ascii_titlecase()
+ .as_str()
+ },
+ |t: TinyAsciiStr<N>| TinyAsciiStr::is_ascii_alphabetic_titlecase(&t),
+ )
+ }
+ check::<2>();
+ check::<3>();
+ check::<4>();
+ check::<5>();
+ check::<8>();
+ check::<16>();
+ }
+
+ #[test]
+ fn test_is_ascii_alphabetic_uppercase() {
+ fn check<const N: usize>() {
+ check_operation(
+ |s| {
+ // Check alphabetic
+ s.chars().all(|c| c.is_ascii_alphabetic()) &&
+ // Check uppercase
+ s == TinyAsciiStr::<16>::try_from_str(s)
+ .unwrap()
+ .to_ascii_uppercase()
+ .as_str()
+ },
+ |t: TinyAsciiStr<N>| TinyAsciiStr::is_ascii_alphabetic_uppercase(&t),
+ )
+ }
+ check::<2>();
+ check::<3>();
+ check::<4>();
+ check::<5>();
+ check::<8>();
+ check::<16>();
+ }
+
+ #[test]
+ fn test_to_ascii_lowercase() {
+ fn check<const N: usize>() {
+ check_operation(
+ |s| {
+ s.chars()
+ .map(|c| c.to_ascii_lowercase())
+ .collect::<String>()
+ },
+ |t: TinyAsciiStr<N>| TinyAsciiStr::to_ascii_lowercase(t).as_str().to_owned(),
+ )
+ }
+ check::<2>();
+ check::<3>();
+ check::<4>();
+ check::<5>();
+ check::<8>();
+ check::<16>();
+ }
+
+ #[test]
+ fn test_to_ascii_titlecase() {
+ fn check<const N: usize>() {
+ check_operation(
+ |s| {
+ let mut r = s
+ .chars()
+ .map(|c| c.to_ascii_lowercase())
+ .collect::<String>();
+ // Safe because the string is nonempty and an ASCII string
+ unsafe { r.as_bytes_mut()[0].make_ascii_uppercase() };
+ r
+ },
+ |t: TinyAsciiStr<N>| TinyAsciiStr::to_ascii_titlecase(t).as_str().to_owned(),
+ )
+ }
+ check::<2>();
+ check::<3>();
+ check::<4>();
+ check::<5>();
+ check::<8>();
+ check::<16>();
+ }
+
+ #[test]
+ fn test_to_ascii_uppercase() {
+ fn check<const N: usize>() {
+ check_operation(
+ |s| {
+ s.chars()
+ .map(|c| c.to_ascii_uppercase())
+ .collect::<String>()
+ },
+ |t: TinyAsciiStr<N>| TinyAsciiStr::to_ascii_uppercase(t).as_str().to_owned(),
+ )
+ }
+ check::<2>();
+ check::<3>();
+ check::<4>();
+ check::<5>();
+ check::<8>();
+ check::<16>();
+ }
+
+ #[test]
+ fn lossy_constructor() {
+ assert_eq!(TinyAsciiStr::<4>::from_utf8_lossy(b"", b'?').as_str(), "");
+ assert_eq!(
+ TinyAsciiStr::<4>::from_utf8_lossy(b"oh\0o", b'?').as_str(),
+ "oh?o"
+ );
+ assert_eq!(
+ TinyAsciiStr::<4>::from_utf8_lossy(b"\0", b'?').as_str(),
+ "?"
+ );
+ assert_eq!(
+ TinyAsciiStr::<4>::from_utf8_lossy(b"toolong", b'?').as_str(),
+ "tool"
+ );
+ assert_eq!(
+ TinyAsciiStr::<4>::from_utf8_lossy(&[b'a', 0x80, 0xFF, b'1'], b'?').as_str(),
+ "a??1"
+ );
+ }
+}
diff --git a/crates/tinystr/src/asciibyte.rs b/crates/tinystr/src/asciibyte.rs
new file mode 100644
index 0000000..f41a033
--- /dev/null
+++ b/crates/tinystr/src/asciibyte.rs
@@ -0,0 +1,145 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+#[repr(u8)]
+#[allow(dead_code)]
+#[derive(PartialEq, Eq, Ord, PartialOrd, Copy, Clone, Hash)]
+pub enum AsciiByte {
+ B0 = 0,
+ B1 = 1,
+ B2 = 2,
+ B3 = 3,
+ B4 = 4,
+ B5 = 5,
+ B6 = 6,
+ B7 = 7,
+ B8 = 8,
+ B9 = 9,
+ B10 = 10,
+ B11 = 11,
+ B12 = 12,
+ B13 = 13,
+ B14 = 14,
+ B15 = 15,
+ B16 = 16,
+ B17 = 17,
+ B18 = 18,
+ B19 = 19,
+ B20 = 20,
+ B21 = 21,
+ B22 = 22,
+ B23 = 23,
+ B24 = 24,
+ B25 = 25,
+ B26 = 26,
+ B27 = 27,
+ B28 = 28,
+ B29 = 29,
+ B30 = 30,
+ B31 = 31,
+ B32 = 32,
+ B33 = 33,
+ B34 = 34,
+ B35 = 35,
+ B36 = 36,
+ B37 = 37,
+ B38 = 38,
+ B39 = 39,
+ B40 = 40,
+ B41 = 41,
+ B42 = 42,
+ B43 = 43,
+ B44 = 44,
+ B45 = 45,
+ B46 = 46,
+ B47 = 47,
+ B48 = 48,
+ B49 = 49,
+ B50 = 50,
+ B51 = 51,
+ B52 = 52,
+ B53 = 53,
+ B54 = 54,
+ B55 = 55,
+ B56 = 56,
+ B57 = 57,
+ B58 = 58,
+ B59 = 59,
+ B60 = 60,
+ B61 = 61,
+ B62 = 62,
+ B63 = 63,
+ B64 = 64,
+ B65 = 65,
+ B66 = 66,
+ B67 = 67,
+ B68 = 68,
+ B69 = 69,
+ B70 = 70,
+ B71 = 71,
+ B72 = 72,
+ B73 = 73,
+ B74 = 74,
+ B75 = 75,
+ B76 = 76,
+ B77 = 77,
+ B78 = 78,
+ B79 = 79,
+ B80 = 80,
+ B81 = 81,
+ B82 = 82,
+ B83 = 83,
+ B84 = 84,
+ B85 = 85,
+ B86 = 86,
+ B87 = 87,
+ B88 = 88,
+ B89 = 89,
+ B90 = 90,
+ B91 = 91,
+ B92 = 92,
+ B93 = 93,
+ B94 = 94,
+ B95 = 95,
+ B96 = 96,
+ B97 = 97,
+ B98 = 98,
+ B99 = 99,
+ B100 = 100,
+ B101 = 101,
+ B102 = 102,
+ B103 = 103,
+ B104 = 104,
+ B105 = 105,
+ B106 = 106,
+ B107 = 107,
+ B108 = 108,
+ B109 = 109,
+ B110 = 110,
+ B111 = 111,
+ B112 = 112,
+ B113 = 113,
+ B114 = 114,
+ B115 = 115,
+ B116 = 116,
+ B117 = 117,
+ B118 = 118,
+ B119 = 119,
+ B120 = 120,
+ B121 = 121,
+ B122 = 122,
+ B123 = 123,
+ B124 = 124,
+ B125 = 125,
+ B126 = 126,
+ B127 = 127,
+}
+
+impl AsciiByte {
+ // Convert [u8; N] to [AsciiByte; N]
+ #[inline]
+ pub const unsafe fn to_ascii_byte_array<const N: usize>(bytes: &[u8; N]) -> [AsciiByte; N] {
+ *(bytes as *const [u8; N] as *const [AsciiByte; N])
+ }
+}
diff --git a/crates/tinystr/src/databake.rs b/crates/tinystr/src/databake.rs
new file mode 100644
index 0000000..748d23a
--- /dev/null
+++ b/crates/tinystr/src/databake.rs
@@ -0,0 +1,75 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use crate::TinyAsciiStr;
+use crate::UnvalidatedTinyAsciiStr;
+use databake::*;
+
+impl<const N: usize> Bake for TinyAsciiStr<N> {
+ fn bake(&self, env: &CrateEnv) -> TokenStream {
+ env.insert("tinystr");
+ let string = self.as_str();
+ quote! {
+ tinystr::tinystr!(#N, #string)
+ }
+ }
+}
+
+impl<const N: usize> BakeSize for TinyAsciiStr<N> {
+ fn borrows_size(&self) -> usize {
+ 0
+ }
+}
+
+impl<const N: usize> databake::Bake for UnvalidatedTinyAsciiStr<N> {
+ fn bake(&self, env: &databake::CrateEnv) -> databake::TokenStream {
+ match self.try_into_tinystr() {
+ Ok(tiny) => {
+ let tiny = tiny.bake(env);
+ databake::quote! {
+ #tiny.to_unvalidated()
+ }
+ }
+ Err(_) => {
+ let bytes = self.0.bake(env);
+ env.insert("tinystr");
+ databake::quote! {
+ tinystr::UnvalidatedTinyAsciiStr::from_utf8_unchecked(#bytes)
+ }
+ }
+ }
+ }
+}
+
+impl<const N: usize> databake::BakeSize for UnvalidatedTinyAsciiStr<N> {
+ fn borrows_size(&self) -> usize {
+ 0
+ }
+}
+
+#[test]
+fn test() {
+ test_bake!(
+ TinyAsciiStr<10>,
+ const,
+ crate::tinystr!(10usize, "foo"),
+ tinystr
+ );
+}
+
+#[test]
+fn test_unvalidated() {
+ test_bake!(
+ UnvalidatedTinyAsciiStr<10>,
+ const,
+ crate::tinystr!(10usize, "foo").to_unvalidated(),
+ tinystr
+ );
+ test_bake!(
+ UnvalidatedTinyAsciiStr<3>,
+ const,
+ crate::UnvalidatedTinyAsciiStr::from_utf8_unchecked(*b"AB\xCD"),
+ tinystr
+ );
+}
diff --git a/crates/tinystr/src/error.rs b/crates/tinystr/src/error.rs
new file mode 100644
index 0000000..9d8237b
--- /dev/null
+++ b/crates/tinystr/src/error.rs
@@ -0,0 +1,19 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use displaydoc::Display;
+
+#[cfg(feature = "std")]
+impl std::error::Error for ParseError {}
+
+#[derive(Display, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum ParseError {
+ #[displaydoc("found string of larger length {len} when constructing string of length {max}")]
+ TooLong { max: usize, len: usize },
+ #[displaydoc("tinystr types do not support strings with null bytes")]
+ ContainsNull,
+ #[displaydoc("attempted to construct TinyAsciiStr from a non-ASCII string")]
+ NonAscii,
+}
diff --git a/crates/tinystr/src/int_ops.rs b/crates/tinystr/src/int_ops.rs
new file mode 100644
index 0000000..7bdb363
--- /dev/null
+++ b/crates/tinystr/src/int_ops.rs
@@ -0,0 +1,315 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use crate::asciibyte::AsciiByte;
+
+/// Internal helper struct that performs operations on aligned integers.
+/// Supports strings up to 4 bytes long.
+#[repr(transparent)]
+pub struct Aligned4(u32);
+
+impl Aligned4 {
+ /// # Panics
+ /// Panics if N is greater than 4
+ #[inline]
+ pub const fn from_utf8<const N: usize>(src: &[u8; N]) -> Self {
+ let mut bytes = [0; 4];
+ let mut i = 0;
+ // The function documentation defines when panics may occur
+ #[allow(clippy::indexing_slicing)]
+ while i < N {
+ bytes[i] = src[i];
+ i += 1;
+ }
+ Self(u32::from_ne_bytes(bytes))
+ }
+
+ #[inline]
+ pub const fn from_ascii_bytes<const N: usize>(src: &[AsciiByte; N]) -> Self {
+ Self::from_utf8::<N>(unsafe { core::mem::transmute::<&[AsciiByte; N], &[u8; N]>(src) })
+ }
+
+ #[inline]
+ pub const fn to_bytes(&self) -> [u8; 4] {
+ self.0.to_ne_bytes()
+ }
+
+ #[inline]
+ pub const fn to_ascii_bytes(&self) -> [AsciiByte; 4] {
+ unsafe { core::mem::transmute(self.to_bytes()) }
+ }
+
+ pub const fn len(&self) -> usize {
+ let word = self.0;
+ #[cfg(target_endian = "little")]
+ let len = (4 - word.leading_zeros() / 8) as usize;
+ #[cfg(target_endian = "big")]
+ let len = (4 - word.trailing_zeros() / 8) as usize;
+ len
+ }
+
+ pub const fn is_ascii_alphabetic(&self) -> bool {
+ let word = self.0;
+ // Each of the following bitmasks set *the high bit* (0x8) to 0 for valid and 1 for invalid.
+ // `mask` sets all NUL bytes to 0.
+ let mask = (word + 0x7f7f_7f7f) & 0x8080_8080;
+ // `lower` converts the string to lowercase. It may also change the value of non-alpha
+ // characters, but this does not matter for the alphabetic test that follows.
+ let lower = word | 0x2020_2020;
+ // `alpha` sets all alphabetic bytes to 0. We only need check for lowercase characters.
+ let alpha = !(lower + 0x1f1f_1f1f) | (lower + 0x0505_0505);
+ // The overall string is valid if every character passes at least one test.
+ // We performed two tests here: non-NUL (`mask`) and alphabetic (`alpha`).
+ (alpha & mask) == 0
+ }
+
+ pub const fn is_ascii_alphanumeric(&self) -> bool {
+ let word = self.0;
+ // See explanatory comments in is_ascii_alphabetic
+ let mask = (word + 0x7f7f_7f7f) & 0x8080_8080;
+ let numeric = !(word + 0x5050_5050) | (word + 0x4646_4646);
+ let lower = word | 0x2020_2020;
+ let alpha = !(lower + 0x1f1f_1f1f) | (lower + 0x0505_0505);
+ (alpha & numeric & mask) == 0
+ }
+
+ pub const fn is_ascii_numeric(&self) -> bool {
+ let word = self.0;
+ // See explanatory comments in is_ascii_alphabetic
+ let mask = (word + 0x7f7f_7f7f) & 0x8080_8080;
+ let numeric = !(word + 0x5050_5050) | (word + 0x4646_4646);
+ (numeric & mask) == 0
+ }
+
+ pub const fn is_ascii_lowercase(&self) -> bool {
+ let word = self.0;
+ // For efficiency, this function tests for an invalid string rather than a valid string.
+ // A string is ASCII lowercase iff it contains no uppercase ASCII characters.
+ // `invalid_case` sets all uppercase ASCII characters to 0 and all others to 1.
+ let invalid_case = !(word + 0x3f3f_3f3f) | (word + 0x2525_2525);
+ // The string is valid if it contains no invalid characters (if all high bits are 1).
+ (invalid_case & 0x8080_8080) == 0x8080_8080
+ }
+
+ pub const fn is_ascii_titlecase(&self) -> bool {
+ let word = self.0;
+ // See explanatory comments in is_ascii_lowercase
+ let invalid_case = if cfg!(target_endian = "little") {
+ !(word + 0x3f3f_3f1f) | (word + 0x2525_2505)
+ } else {
+ !(word + 0x1f3f_3f3f) | (word + 0x0525_2525)
+ };
+ (invalid_case & 0x8080_8080) == 0x8080_8080
+ }
+
+ pub const fn is_ascii_uppercase(&self) -> bool {
+ let word = self.0;
+ // See explanatory comments in is_ascii_lowercase
+ let invalid_case = !(word + 0x1f1f_1f1f) | (word + 0x0505_0505);
+ (invalid_case & 0x8080_8080) == 0x8080_8080
+ }
+
+ pub const fn is_ascii_alphabetic_lowercase(&self) -> bool {
+ let word = self.0;
+ // `mask` sets all NUL bytes to 0.
+ let mask = (word + 0x7f7f_7f7f) & 0x8080_8080;
+ // `lower_alpha` sets all lowercase ASCII characters to 0 and all others to 1.
+ let lower_alpha = !(word + 0x1f1f_1f1f) | (word + 0x0505_0505);
+ // The overall string is valid if every character passes at least one test.
+ // We performed two tests here: non-NUL (`mask`) and lowercase ASCII character (`alpha`).
+ (lower_alpha & mask) == 0
+ }
+
+ pub const fn is_ascii_alphabetic_titlecase(&self) -> bool {
+ let word = self.0;
+ // See explanatory comments in is_ascii_alphabetic_lowercase
+ let mask = (word + 0x7f7f_7f7f) & 0x8080_8080;
+ let title_case = if cfg!(target_endian = "little") {
+ !(word + 0x1f1f_1f3f) | (word + 0x0505_0525)
+ } else {
+ !(word + 0x3f1f_1f1f) | (word + 0x2505_0505)
+ };
+ (title_case & mask) == 0
+ }
+
+ pub const fn is_ascii_alphabetic_uppercase(&self) -> bool {
+ let word = self.0;
+ // See explanatory comments in is_ascii_alphabetic_lowercase
+ let mask = (word + 0x7f7f_7f7f) & 0x8080_8080;
+ let upper_alpha = !(word + 0x3f3f_3f3f) | (word + 0x2525_2525);
+ (upper_alpha & mask) == 0
+ }
+
+ pub const fn to_ascii_lowercase(&self) -> Self {
+ let word = self.0;
+ let result = word | (((word + 0x3f3f_3f3f) & !(word + 0x2525_2525) & 0x8080_8080) >> 2);
+ Self(result)
+ }
+
+ pub const fn to_ascii_titlecase(&self) -> Self {
+ let word = self.0.to_le();
+ let mask = ((word + 0x3f3f_3f1f) & !(word + 0x2525_2505) & 0x8080_8080) >> 2;
+ let result = (word | mask) & !(0x20 & mask);
+ Self(u32::from_le(result))
+ }
+
+ pub const fn to_ascii_uppercase(&self) -> Self {
+ let word = self.0;
+ let result = word & !(((word + 0x1f1f_1f1f) & !(word + 0x0505_0505) & 0x8080_8080) >> 2);
+ Self(result)
+ }
+}
+
+/// Internal helper struct that performs operations on aligned integers.
+/// Supports strings up to 8 bytes long.
+#[repr(transparent)]
+pub struct Aligned8(u64);
+
+impl Aligned8 {
+ /// # Panics
+ /// Panics if N is greater than 8
+ #[inline]
+ pub const fn from_utf8<const N: usize>(src: &[u8; N]) -> Self {
+ let mut bytes = [0; 8];
+ let mut i = 0;
+ // The function documentation defines when panics may occur
+ #[allow(clippy::indexing_slicing)]
+ while i < N {
+ bytes[i] = src[i];
+ i += 1;
+ }
+ Self(u64::from_ne_bytes(bytes))
+ }
+
+ #[inline]
+ pub const fn from_ascii_bytes<const N: usize>(src: &[AsciiByte; N]) -> Self {
+ Self::from_utf8::<N>(unsafe { core::mem::transmute::<&[AsciiByte; N], &[u8; N]>(src) })
+ }
+
+ #[inline]
+ pub const fn to_bytes(&self) -> [u8; 8] {
+ self.0.to_ne_bytes()
+ }
+
+ #[inline]
+ pub const fn to_ascii_bytes(&self) -> [AsciiByte; 8] {
+ unsafe { core::mem::transmute(self.to_bytes()) }
+ }
+
+ pub const fn len(&self) -> usize {
+ let word = self.0;
+ #[cfg(target_endian = "little")]
+ let len = (8 - word.leading_zeros() / 8) as usize;
+ #[cfg(target_endian = "big")]
+ let len = (8 - word.trailing_zeros() / 8) as usize;
+ len
+ }
+
+ pub const fn is_ascii_alphabetic(&self) -> bool {
+ let word = self.0;
+ let mask = (word + 0x7f7f_7f7f_7f7f_7f7f) & 0x8080_8080_8080_8080;
+ let lower = word | 0x2020_2020_2020_2020;
+ let alpha = !(lower + 0x1f1f_1f1f_1f1f_1f1f) | (lower + 0x0505_0505_0505_0505);
+ (alpha & mask) == 0
+ }
+
+ pub const fn is_ascii_alphanumeric(&self) -> bool {
+ let word = self.0;
+ let mask = (word + 0x7f7f_7f7f_7f7f_7f7f) & 0x8080_8080_8080_8080;
+ let numeric = !(word + 0x5050_5050_5050_5050) | (word + 0x4646_4646_4646_4646);
+ let lower = word | 0x2020_2020_2020_2020;
+ let alpha = !(lower + 0x1f1f_1f1f_1f1f_1f1f) | (lower + 0x0505_0505_0505_0505);
+ (alpha & numeric & mask) == 0
+ }
+
+ pub const fn is_ascii_numeric(&self) -> bool {
+ let word = self.0;
+ let mask = (word + 0x7f7f_7f7f_7f7f_7f7f) & 0x8080_8080_8080_8080;
+ let numeric = !(word + 0x5050_5050_5050_5050) | (word + 0x4646_4646_4646_4646);
+ (numeric & mask) == 0
+ }
+
+ pub const fn is_ascii_lowercase(&self) -> bool {
+ let word = self.0;
+ let invalid_case = !(word + 0x3f3f_3f3f_3f3f_3f3f) | (word + 0x2525_2525_2525_2525);
+ (invalid_case & 0x8080_8080_8080_8080) == 0x8080_8080_8080_8080
+ }
+
+ pub const fn is_ascii_titlecase(&self) -> bool {
+ let word = self.0;
+ let invalid_case = if cfg!(target_endian = "little") {
+ !(word + 0x3f3f_3f3f_3f3f_3f1f) | (word + 0x2525_2525_2525_2505)
+ } else {
+ !(word + 0x1f3f_3f3f_3f3f_3f3f) | (word + 0x0525_2525_2525_2525)
+ };
+ (invalid_case & 0x8080_8080_8080_8080) == 0x8080_8080_8080_8080
+ }
+
+ pub const fn is_ascii_uppercase(&self) -> bool {
+ let word = self.0;
+ let invalid_case = !(word + 0x1f1f_1f1f_1f1f_1f1f) | (word + 0x0505_0505_0505_0505);
+ (invalid_case & 0x8080_8080_8080_8080) == 0x8080_8080_8080_8080
+ }
+
+ pub const fn is_ascii_alphabetic_lowercase(&self) -> bool {
+ let word = self.0;
+ // `mask` sets all NUL bytes to 0.
+ let mask = (word + 0x7f7f_7f7f_7f7f_7f7f) & 0x8080_8080_8080_8080;
+ // `lower_alpha` sets all lowercase ASCII characters to 0 and all others to 1.
+ let lower_alpha = !(word + 0x1f1f_1f1f_1f1f_1f1f) | (word + 0x0505_0505_0505_0505);
+ // The overall string is valid if every character passes at least one test.
+ // We performed two tests here: non-NUL (`mask`) and lowercase ASCII character (`alpha`).
+ (lower_alpha & mask) == 0
+ }
+
+ pub const fn is_ascii_alphabetic_titlecase(&self) -> bool {
+ let word = self.0;
+ // See explanatory comments in is_ascii_alphabetic_lowercase
+ let mask = (word + 0x7f7f_7f7f_7f7f_7f7f) & 0x8080_8080_8080_8080;
+ let title_case = if cfg!(target_endian = "little") {
+ !(word + 0x1f1f_1f1f_1f1f_1f3f) | (word + 0x0505_0505_0505_0525)
+ } else {
+ !(word + 0x3f1f_1f1f_1f1f_1f1f) | (word + 0x2505_0505_0505_0505)
+ };
+ (title_case & mask) == 0
+ }
+
+ pub const fn is_ascii_alphabetic_uppercase(&self) -> bool {
+ let word = self.0;
+ // See explanatory comments in is_ascii_alphabetic_lowercase
+ let mask = (word + 0x7f7f_7f7f_7f7f_7f7f) & 0x8080_8080_8080_8080;
+ let upper_alpha = !(word + 0x3f3f_3f3f_3f3f_3f3f) | (word + 0x2525_2525_2525_2525);
+ (upper_alpha & mask) == 0
+ }
+
+ pub const fn to_ascii_lowercase(&self) -> Self {
+ let word = self.0;
+ let result = word
+ | (((word + 0x3f3f_3f3f_3f3f_3f3f)
+ & !(word + 0x2525_2525_2525_2525)
+ & 0x8080_8080_8080_8080)
+ >> 2);
+ Self(result)
+ }
+
+ pub const fn to_ascii_titlecase(&self) -> Self {
+ let word = self.0.to_le();
+ let mask = ((word + 0x3f3f_3f3f_3f3f_3f1f)
+ & !(word + 0x2525_2525_2525_2505)
+ & 0x8080_8080_8080_8080)
+ >> 2;
+ let result = (word | mask) & !(0x20 & mask);
+ Self(u64::from_le(result))
+ }
+
+ pub const fn to_ascii_uppercase(&self) -> Self {
+ let word = self.0;
+ let result = word
+ & !(((word + 0x1f1f_1f1f_1f1f_1f1f)
+ & !(word + 0x0505_0505_0505_0505)
+ & 0x8080_8080_8080_8080)
+ >> 2);
+ Self(result)
+ }
+}
diff --git a/crates/tinystr/src/lib.rs b/crates/tinystr/src/lib.rs
new file mode 100644
index 0000000..ab1bfc4
--- /dev/null
+++ b/crates/tinystr/src/lib.rs
@@ -0,0 +1,113 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+//! `tinystr` is a utility crate of the [`ICU4X`] project.
+//!
+//! It includes [`TinyAsciiStr`], a core API for representing small ASCII-only bounded length strings.
+//!
+//! It is optimized for operations on strings of size 8 or smaller. When use cases involve comparison
+//! and conversion of strings for lowercase/uppercase/titlecase, or checking
+//! numeric/alphabetic/alphanumeric, `TinyAsciiStr` is the edge performance library.
+//!
+//! # Examples
+//!
+//! ```rust
+//! use tinystr::TinyAsciiStr;
+//!
+//! let s1: TinyAsciiStr<4> = "tEsT".parse().expect("Failed to parse.");
+//!
+//! assert_eq!(s1, "tEsT");
+//! assert_eq!(s1.to_ascii_uppercase(), "TEST");
+//! assert_eq!(s1.to_ascii_lowercase(), "test");
+//! assert_eq!(s1.to_ascii_titlecase(), "Test");
+//! assert!(s1.is_ascii_alphanumeric());
+//! assert!(!s1.is_ascii_numeric());
+//!
+//! let s2 = TinyAsciiStr::<8>::try_from_raw(*b"New York")
+//! .expect("Failed to parse.");
+//!
+//! assert_eq!(s2, "New York");
+//! assert_eq!(s2.to_ascii_uppercase(), "NEW YORK");
+//! assert_eq!(s2.to_ascii_lowercase(), "new york");
+//! assert_eq!(s2.to_ascii_titlecase(), "New york");
+//! assert!(!s2.is_ascii_alphanumeric());
+//! ```
+//!
+//! # Details
+//!
+//! When strings are of size 8 or smaller, the struct transforms the strings as `u32`/`u64` and uses
+//! bitmasking to provide basic string manipulation operations:
+//! * `is_ascii_numeric`
+//! * `is_ascii_alphabetic`
+//! * `is_ascii_alphanumeric`
+//! * `to_ascii_lowercase`
+//! * `to_ascii_uppercase`
+//! * `to_ascii_titlecase`
+//! * `PartialEq`
+//!
+//! `TinyAsciiStr` will fall back to `u8` character manipulation for strings of length greater than 8.
+
+//!
+//! [`ICU4X`]: ../icu/index.html
+
+// https://github.com/unicode-org/icu4x/blob/main/documents/process/boilerplate.md#library-annotations
+#![cfg_attr(not(any(test, feature = "std")), no_std)]
+#![cfg_attr(
+ not(test),
+ deny(
+ clippy::indexing_slicing,
+ clippy::unwrap_used,
+ clippy::expect_used,
+ clippy::panic,
+ clippy::exhaustive_structs,
+ clippy::exhaustive_enums,
+ missing_debug_implementations,
+ )
+)]
+
+mod macros;
+
+mod ascii;
+mod asciibyte;
+mod error;
+mod int_ops;
+mod unvalidated;
+
+#[cfg(feature = "serde")]
+mod serde;
+
+#[cfg(feature = "databake")]
+mod databake;
+
+#[cfg(feature = "zerovec")]
+mod ule;
+
+#[cfg(any(feature = "serde", feature = "alloc"))]
+extern crate alloc;
+
+pub use ascii::TinyAsciiStr;
+pub use error::ParseError;
+pub use unvalidated::UnvalidatedTinyAsciiStr;
+
+/// These are temporary compatability reexports that will be removed
+/// in a future version.
+pub type TinyStr4 = TinyAsciiStr<4>;
+/// These are temporary compatability reexports that will be removed
+/// in a future version.
+pub type TinyStr8 = TinyAsciiStr<8>;
+/// These are temporary compatability reexports that will be removed
+/// in a future version.
+pub type TinyStr16 = TinyAsciiStr<16>;
+
+#[test]
+fn test_size() {
+ assert_eq!(
+ core::mem::size_of::<TinyStr4>(),
+ core::mem::size_of::<Option<TinyStr4>>()
+ );
+ assert_eq!(
+ core::mem::size_of::<TinyStr8>(),
+ core::mem::size_of::<Option<TinyStr8>>()
+ );
+}
diff --git a/crates/tinystr/src/macros.rs b/crates/tinystr/src/macros.rs
new file mode 100644
index 0000000..30dc445
--- /dev/null
+++ b/crates/tinystr/src/macros.rs
@@ -0,0 +1,32 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+#[macro_export]
+macro_rules! tinystr {
+ ($n:literal, $s:literal) => {{
+ // Force it into a const context; otherwise it may get evaluated at runtime instead.
+ const TINYSTR_MACRO_CONST: $crate::TinyAsciiStr<$n> = {
+ match $crate::TinyAsciiStr::try_from_utf8($s.as_bytes()) {
+ Ok(s) => s,
+ // We are okay with panicking here because this is in a const context
+ #[allow(clippy::panic)]
+ // Cannot format the error since formatting isn't const yet
+ Err(_) => panic!(concat!("Failed to construct tinystr from ", $s)),
+ }
+ };
+ TINYSTR_MACRO_CONST
+ }};
+}
+
+#[cfg(test)]
+mod tests {
+ #[test]
+ fn test_macro_construction() {
+ let s1 = tinystr!(8, "foobar");
+ assert_eq!(&*s1, "foobar");
+
+ let s1 = tinystr!(12, "foobarbaz");
+ assert_eq!(&*s1, "foobarbaz");
+ }
+}
diff --git a/crates/tinystr/src/serde.rs b/crates/tinystr/src/serde.rs
new file mode 100644
index 0000000..529902b
--- /dev/null
+++ b/crates/tinystr/src/serde.rs
@@ -0,0 +1,91 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use crate::TinyAsciiStr;
+use alloc::borrow::Cow;
+use alloc::string::ToString;
+use core::fmt;
+use core::marker::PhantomData;
+use core::ops::Deref;
+use serde::de::{Error, SeqAccess, Visitor};
+use serde::ser::SerializeTuple;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+impl<const N: usize> Serialize for TinyAsciiStr<N> {
+ #[inline]
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ if serializer.is_human_readable() {
+ self.deref().serialize(serializer)
+ } else {
+ let mut seq = serializer.serialize_tuple(N)?;
+ for byte in self.all_bytes() {
+ seq.serialize_element(byte)?;
+ }
+ seq.end()
+ }
+ }
+}
+
+struct TinyAsciiStrVisitor<const N: usize> {
+ marker: PhantomData<TinyAsciiStr<N>>,
+}
+
+impl<const N: usize> TinyAsciiStrVisitor<N> {
+ fn new() -> Self {
+ TinyAsciiStrVisitor {
+ marker: PhantomData,
+ }
+ }
+}
+
+impl<'de, const N: usize> Visitor<'de> for TinyAsciiStrVisitor<N> {
+ type Value = TinyAsciiStr<N>;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ write!(formatter, "a TinyAsciiStr<{N}>")
+ }
+
+ #[inline]
+ fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+ where
+ A: SeqAccess<'de>,
+ {
+ let mut bytes = [0u8; N];
+ let mut zeroes = false;
+ for out in &mut bytes.iter_mut().take(N) {
+ let byte = seq
+ .next_element()?
+ .ok_or_else(|| Error::invalid_length(N, &self))?;
+ if byte == 0 {
+ zeroes = true;
+ } else if zeroes {
+ return Err(Error::custom("TinyAsciiStr cannot contain null bytes"));
+ }
+
+ if byte >= 0x80 {
+ return Err(Error::custom("TinyAsciiStr cannot contain non-ascii bytes"));
+ }
+ *out = byte;
+ }
+
+ Ok(unsafe { TinyAsciiStr::from_utf8_unchecked(bytes) })
+ }
+}
+
+impl<'de, const N: usize> Deserialize<'de> for TinyAsciiStr<N> {
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ if deserializer.is_human_readable() {
+ let x: Cow<'de, str> = Deserialize::deserialize(deserializer)?;
+ TinyAsciiStr::try_from_str(&x).map_err(|e| Error::custom(e.to_string()))
+ } else {
+ deserializer.deserialize_tuple(N, TinyAsciiStrVisitor::<N>::new())
+ }
+ }
+}
diff --git a/crates/tinystr/src/ule.rs b/crates/tinystr/src/ule.rs
new file mode 100644
index 0000000..c6b8782
--- /dev/null
+++ b/crates/tinystr/src/ule.rs
@@ -0,0 +1,121 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use crate::{TinyAsciiStr, UnvalidatedTinyAsciiStr};
+use zerovec::maps::ZeroMapKV;
+use zerovec::ule::*;
+use zerovec::{ZeroSlice, ZeroVec};
+
+// Safety (based on the safety checklist on the ULE trait):
+// 1. TinyAsciiStr does not include any uninitialized or padding bytes.
+// (achieved by `#[repr(transparent)]` on a type that satisfies this invariant)
+// 2. TinyAsciiStr is aligned to 1 byte.
+// (achieved by `#[repr(transparent)]` on a type that satisfies this invariant)
+// 3. The impl of validate_bytes() returns an error if any byte is not valid.
+// 4. The impl of validate_bytes() returns an error if there are extra bytes.
+// 5. The other ULE methods use the default impl.
+// 6. TinyAsciiStr byte equality is semantic equality
+unsafe impl<const N: usize> ULE for TinyAsciiStr<N> {
+ #[inline]
+ fn validate_bytes(bytes: &[u8]) -> Result<(), UleError> {
+ if bytes.len() % N != 0 {
+ return Err(UleError::length::<Self>(bytes.len()));
+ }
+ // Validate the bytes
+ for chunk in bytes.chunks_exact(N) {
+ let _ = TinyAsciiStr::<N>::try_from_utf8_inner(chunk, true)
+ .map_err(|_| UleError::parse::<Self>())?;
+ }
+ Ok(())
+ }
+}
+
+impl<const N: usize> NicheBytes<N> for TinyAsciiStr<N> {
+ // AsciiByte is 0..128
+ const NICHE_BIT_PATTERN: [u8; N] = [255; N];
+}
+
+impl<const N: usize> AsULE for TinyAsciiStr<N> {
+ type ULE = Self;
+
+ #[inline]
+ fn to_unaligned(self) -> Self::ULE {
+ self
+ }
+
+ #[inline]
+ fn from_unaligned(unaligned: Self::ULE) -> Self {
+ unaligned
+ }
+}
+
+impl<'a, const N: usize> ZeroMapKV<'a> for TinyAsciiStr<N> {
+ type Container = ZeroVec<'a, TinyAsciiStr<N>>;
+ type Slice = ZeroSlice<TinyAsciiStr<N>>;
+ type GetType = TinyAsciiStr<N>;
+ type OwnedType = TinyAsciiStr<N>;
+}
+
+// Safety (based on the safety checklist on the ULE trait):
+// 1. UnvalidatedTinyAsciiStr does not include any uninitialized or padding bytes.
+// (achieved by `#[repr(transparent)]` on a type that satisfies this invariant)
+// 2. UnvalidatedTinyAsciiStr is aligned to 1 byte.
+// (achieved by `#[repr(transparent)]` on a type that satisfies this invariant)
+// 3. The impl of validate_bytes() returns an error if any byte is not valid.
+// 4. The impl of validate_bytes() returns an error if there are extra bytes.
+// 5. The other ULE methods use the default impl.
+// 6. UnvalidatedTinyAsciiStr byte equality is semantic equality
+unsafe impl<const N: usize> ULE for UnvalidatedTinyAsciiStr<N> {
+ #[inline]
+ fn validate_bytes(bytes: &[u8]) -> Result<(), UleError> {
+ if bytes.len() % N != 0 {
+ return Err(UleError::length::<Self>(bytes.len()));
+ }
+ Ok(())
+ }
+}
+
+impl<const N: usize> AsULE for UnvalidatedTinyAsciiStr<N> {
+ type ULE = Self;
+
+ #[inline]
+ fn to_unaligned(self) -> Self::ULE {
+ self
+ }
+
+ #[inline]
+ fn from_unaligned(unaligned: Self::ULE) -> Self {
+ unaligned
+ }
+}
+
+impl<'a, const N: usize> ZeroMapKV<'a> for UnvalidatedTinyAsciiStr<N> {
+ type Container = ZeroVec<'a, UnvalidatedTinyAsciiStr<N>>;
+ type Slice = ZeroSlice<UnvalidatedTinyAsciiStr<N>>;
+ type GetType = UnvalidatedTinyAsciiStr<N>;
+ type OwnedType = UnvalidatedTinyAsciiStr<N>;
+}
+
+#[cfg(test)]
+mod test {
+ use crate::*;
+ use zerovec::*;
+
+ #[test]
+ fn test_zerovec() {
+ let mut vec = ZeroVec::<TinyAsciiStr<7>>::new();
+
+ vec.with_mut(|v| v.push("foobar".parse().unwrap()));
+ vec.with_mut(|v| v.push("baz".parse().unwrap()));
+ vec.with_mut(|v| v.push("quux".parse().unwrap()));
+
+ let bytes = vec.as_bytes();
+
+ let vec: ZeroVec<TinyAsciiStr<7>> = ZeroVec::parse_bytes(bytes).unwrap();
+
+ assert_eq!(&*vec.get(0).unwrap(), "foobar");
+ assert_eq!(&*vec.get(1).unwrap(), "baz");
+ assert_eq!(&*vec.get(2).unwrap(), "quux");
+ }
+}
diff --git a/crates/tinystr/src/unvalidated.rs b/crates/tinystr/src/unvalidated.rs
new file mode 100644
index 0000000..3758b64
--- /dev/null
+++ b/crates/tinystr/src/unvalidated.rs
@@ -0,0 +1,122 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use crate::ParseError;
+use crate::TinyAsciiStr;
+use core::fmt;
+
+/// A fixed-length bytes array that is expected to be an ASCII string but does not enforce that invariant.
+///
+/// Use this type instead of `TinyAsciiStr` if you don't need to enforce ASCII during deserialization. For
+/// example, strings that are keys of a map don't need to ever be reified as `TinyAsciiStr`s.
+///
+/// The main advantage of this type over `[u8; N]` is that it serializes as a string in
+/// human-readable formats like JSON.
+#[derive(PartialEq, PartialOrd, Eq, Ord, Clone, Copy)]
+pub struct UnvalidatedTinyAsciiStr<const N: usize>(pub(crate) [u8; N]);
+
+impl<const N: usize> fmt::Debug for UnvalidatedTinyAsciiStr<N> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ // Debug as a string if possible
+ match self.try_into_tinystr() {
+ Ok(s) => fmt::Debug::fmt(&s, f),
+ Err(_) => fmt::Debug::fmt(&self.0, f),
+ }
+ }
+}
+
+impl<const N: usize> UnvalidatedTinyAsciiStr<N> {
+ #[inline]
+ /// Converts into a [`TinyAsciiStr`]. Fails if the bytes are not valid ASCII.
+ pub fn try_into_tinystr(self) -> Result<TinyAsciiStr<N>, ParseError> {
+ TinyAsciiStr::try_from_raw(self.0)
+ }
+
+ #[inline]
+ /// Unsafely converts into a [`TinyAsciiStr`].
+ pub const fn from_utf8_unchecked(bytes: [u8; N]) -> Self {
+ Self(bytes)
+ }
+}
+
+impl<const N: usize> TinyAsciiStr<N> {
+ #[inline]
+ // Converts into a [`UnvalidatedTinyAsciiStr`]
+ pub const fn to_unvalidated(self) -> UnvalidatedTinyAsciiStr<N> {
+ UnvalidatedTinyAsciiStr(*self.all_bytes())
+ }
+}
+
+impl<const N: usize> From<TinyAsciiStr<N>> for UnvalidatedTinyAsciiStr<N> {
+ fn from(other: TinyAsciiStr<N>) -> Self {
+ other.to_unvalidated()
+ }
+}
+
+#[cfg(feature = "serde")]
+impl<const N: usize> serde::Serialize for UnvalidatedTinyAsciiStr<N> {
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: serde::Serializer,
+ {
+ use serde::ser::Error;
+ self.try_into_tinystr()
+ .map_err(|_| S::Error::custom("invalid ascii in UnvalidatedTinyAsciiStr"))?
+ .serialize(serializer)
+ }
+}
+
+macro_rules! deserialize {
+ ($size:literal) => {
+ #[cfg(feature = "serde")]
+ impl<'de, 'a> serde::Deserialize<'de> for UnvalidatedTinyAsciiStr<$size>
+ where
+ 'de: 'a,
+ {
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+ where
+ D: serde::Deserializer<'de>,
+ {
+ if deserializer.is_human_readable() {
+ Ok(TinyAsciiStr::deserialize(deserializer)?.to_unvalidated())
+ } else {
+ Ok(Self(<[u8; $size]>::deserialize(deserializer)?))
+ }
+ }
+ }
+ };
+}
+
+deserialize!(1);
+deserialize!(2);
+deserialize!(3);
+deserialize!(4);
+deserialize!(5);
+deserialize!(6);
+deserialize!(7);
+deserialize!(8);
+deserialize!(9);
+deserialize!(10);
+deserialize!(11);
+deserialize!(12);
+deserialize!(13);
+deserialize!(14);
+deserialize!(15);
+deserialize!(16);
+deserialize!(17);
+deserialize!(18);
+deserialize!(19);
+deserialize!(20);
+deserialize!(21);
+deserialize!(22);
+deserialize!(23);
+deserialize!(24);
+deserialize!(25);
+deserialize!(26);
+deserialize!(27);
+deserialize!(28);
+deserialize!(29);
+deserialize!(30);
+deserialize!(31);
+deserialize!(32);
diff --git a/crates/tinystr/tests/serde.rs b/crates/tinystr/tests/serde.rs
new file mode 100644
index 0000000..282914e
--- /dev/null
+++ b/crates/tinystr/tests/serde.rs
@@ -0,0 +1,39 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use tinystr::*;
+
+// Tests largely adapted from `tinystr` crate
+// https://github.com/zbraniecki/tinystr/blob/4e4eab55dd6bded7f29a18b41452c506c461716c/tests/serde.rs
+
+macro_rules! test_roundtrip {
+ ($f:ident, $n:literal, $val:expr) => {
+ #[test]
+ fn $f() {
+ let tiny: TinyAsciiStr<$n> = $val.parse().unwrap();
+ let json_string = serde_json::to_string(&tiny).unwrap();
+ let expected_json = concat!("\"", $val, "\"");
+ assert_eq!(json_string, expected_json);
+ let recover: TinyAsciiStr<$n> = serde_json::from_str(&json_string).unwrap();
+ assert_eq!(&*tiny, &*recover);
+
+ let bin = bincode::serialize(&tiny).unwrap();
+ assert_eq!(bin, &tiny.all_bytes()[..]);
+ let debin: TinyAsciiStr<$n> = bincode::deserialize(&bin).unwrap();
+ assert_eq!(&*tiny, &*debin);
+
+ let post = postcard::to_stdvec(&tiny).unwrap();
+ assert_eq!(post, &tiny.all_bytes()[..]);
+ let unpost: TinyAsciiStr<$n> = postcard::from_bytes(&post).unwrap();
+ assert_eq!(&*tiny, &*unpost);
+ }
+ };
+}
+
+test_roundtrip!(test_roundtrip4_1, 4, "en");
+test_roundtrip!(test_roundtrip4_2, 4, "Latn");
+test_roundtrip!(test_roundtrip8, 8, "calendar");
+test_roundtrip!(test_roundtrip16, 16, "verylongstring");
+test_roundtrip!(test_roundtrip10, 11, "shortstring");
+test_roundtrip!(test_roundtrip30, 24, "veryveryverylongstring");
diff --git a/pseudo_crate/Cargo.lock b/pseudo_crate/Cargo.lock
index 223b8ab..3511c61 100644
--- a/pseudo_crate/Cargo.lock
+++ b/pseudo_crate/Cargo.lock
@@ -423,6 +423,7 @@
"threadpool",
"tikv-jemalloc-sys",
"tikv-jemallocator",
+ "tinystr",
"tinytemplate",
"tinyvec",
"tinyvec_macros",
@@ -5306,6 +5307,15 @@
checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
[[package]]
+name = "tinystr"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2b56a820bb70060f096338fcc02edb78cb3f8fb21c5078503f48588cfcaf494"
+dependencies = [
+ "displaydoc",
+]
+
+[[package]]
name = "tinytemplate"
version = "1.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
diff --git a/pseudo_crate/Cargo.toml b/pseudo_crate/Cargo.toml
index 40951e4..171314f 100644
--- a/pseudo_crate/Cargo.toml
+++ b/pseudo_crate/Cargo.toml
@@ -332,6 +332,7 @@
threadpool = "=1.8.1"
tikv-jemalloc-sys = "=0.5.4"
tikv-jemallocator = "=0.5.4"
+tinystr = "=0.8.0"
tinytemplate = "=1.2.1"
tinyvec = "=1.6.0"
tinyvec_macros = "=0.1.1"
diff --git a/pseudo_crate/crate-list.txt b/pseudo_crate/crate-list.txt
index fc7d606..48062a3 100644
--- a/pseudo_crate/crate-list.txt
+++ b/pseudo_crate/crate-list.txt
@@ -326,6 +326,7 @@
threadpool
tikv-jemalloc-sys
tikv-jemallocator
+tinystr
tinytemplate
tinyvec
tinyvec_macros
