UnicodeSet L1 Work

Cargo.toml

@@ -3,5 +3,6 @@
 members = [
     "components/icu",
     "components/icu4x",
+    "components/uniset",
     "components/locale",
 ]

components/uniset/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "icu-unicodeset"
+description = "API for managing Unicode Language and Locale Identifiers"
+version = "0.0.1"
+authors = ["The ICU4X Project Developers"]
+edition = "2018"
+readme = "README.md"
+repository = "https://github.com/unicode-org/icu4x"
+license-file = "../../LICENSE"
+categories = ["internationalization"]
+include = [
+    "src/**/*",
+    "Cargo.toml",
+]
+
+[dev-dependencies]
+criterion = "0.3"
+
+[[bench]]
+name = "inv_list"
+harness = false

components/uniset/README.md

@@ -0,0 +1,12 @@
+# ICU4X
+
+ICU4X is a set of internationalization components for Unicode.
+
+# Status [![crates.io](http://meritbadge.herokuapp.com/icu4x)](https://crates.io/crates/icu4x)
+
+The project is in an incubation period.
+
+# Authors
+
+The project is managed by a subcommittee of ICU-TC in the Unicode Consortium focused on providing solutions for client-side internationalization.
+

components/uniset/benches/inv_list.rs

@@ -0,0 +1,43 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use icu_unicodeset::UnicodeSet;
+use std::{char, convert::TryFrom};
+
+fn contains_bench(c: &mut Criterion) {
+    let best_ex = vec![65, 70];
+    let best_sample = UnicodeSet::try_from(best_ex).unwrap();
+    let worst_ex: Vec<u32> = (0..((char::MAX as u32) + 1)).collect();
+    let worst_sample = UnicodeSet::try_from(worst_ex).unwrap();
+
+    let mut group = c.benchmark_group("uniset/contains");
+    group.bench_with_input("best", &best_sample, |b, sample| {
+        b.iter(|| sample.iter().map(|ch| sample.contains(ch)))
+    });
+    group.bench_with_input("worst", &worst_sample, |b, sample| {
+        b.iter(|| sample.iter().take(100).map(|ch| sample.contains(ch)))
+    });
+    group.finish();
+}
+
+fn contains_range_bench(c: &mut Criterion) {
+    let best_ex = vec![65, 70];
+    let best_sample = UnicodeSet::try_from(best_ex).unwrap();
+    let worst_ex: Vec<u32> = (0..((char::MAX as u32) + 1)).collect();
+    let worst_sample = UnicodeSet::try_from(worst_ex).unwrap();
+
+    let mut group = c.benchmark_group("uniset/contains_range");
+    group.bench_with_input("best", &best_sample, |b, sample| {
+        b.iter(|| sample.iter().map(|ch| sample.contains_range(&('A'..ch))))
+    });
+    group.bench_with_input("worst", &worst_sample, |b, sample| {
+        b.iter(|| {
+            sample
+                .iter()
+                .take(100)
+                .map(|ch| sample.contains_range(&(char::from_u32(0).unwrap()..ch)))
+        })
+    });
+    group.finish();
+}
+
+criterion_group!(benches, contains_bench, contains_range_bench);
+criterion_main!(benches);

components/uniset/src/conversions.rs

@@ -0,0 +1,121 @@
+use super::USetError;
+use crate::utils::deconstruct_range;
+use crate::UnicodeSet;
+use std::{
+    convert::TryFrom,
+    ops::{Range, RangeBounds, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive},
+};
+
+fn try_from_range(range: &impl RangeBounds<char>) -> Result<UnicodeSet, USetError> {
+    let (from, till) = deconstruct_range(range);
+    if from < till {
+        let set = vec![from, till];
+        Ok(UnicodeSet::try_from(set).unwrap())
+    } else {
+        Err(USetError::InvalidRange(from, till))
+    }
+}
+
+impl TryFrom<&Range<char>> for UnicodeSet {
+    type Error = USetError;
+
+    fn try_from(range: &Range<char>) -> Result<Self, Self::Error> {
+        try_from_range(range)
+    }
+}
+
+impl TryFrom<&RangeFrom<char>> for UnicodeSet {
+    type Error = USetError;
+
+    fn try_from(range: &RangeFrom<char>) -> Result<Self, Self::Error> {
+        try_from_range(range)
+    }
+}
+
+impl TryFrom<&RangeFull> for UnicodeSet {
+    type Error = USetError;
+
+    fn try_from(_: &RangeFull) -> Result<Self, Self::Error> {
+        Ok(UnicodeSet::all())
+    }
+}
+
+impl TryFrom<&RangeInclusive<char>> for UnicodeSet {
+    type Error = USetError;
+
+    fn try_from(range: &RangeInclusive<char>) -> Result<Self, Self::Error> {
+        try_from_range(range)
+    }
+}
+
+impl TryFrom<&RangeTo<char>> for UnicodeSet {
+    type Error = USetError;
+
+    fn try_from(range: &RangeTo<char>) -> Result<Self, Self::Error> {
+        try_from_range(range)
+    }
+}
+
+impl TryFrom<&RangeToInclusive<char>> for UnicodeSet {
+    type Error = USetError;
+
+    fn try_from(range: &RangeToInclusive<char>) -> Result<Self, Self::Error> {
+        try_from_range(range)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::USetError;
+    use crate::UnicodeSet;
+    use std::convert::TryFrom;
+    #[test]
+    fn test_try_from_range() {
+        let check: Vec<char> = UnicodeSet::try_from(&('A'..'B')).unwrap().iter().collect();
+        assert_eq!(vec!['A'], check);
+    }
+    #[test]
+    fn test_try_from_range_error() {
+        let check = UnicodeSet::try_from(&('A'..'A'));
+        assert_eq!(Err(USetError::InvalidRange(65, 65)), check);
+    }
+    #[test]
+    fn test_try_from_range_inclusive() {
+        let check: Vec<char> = UnicodeSet::try_from(&('A'..='A')).unwrap().iter().collect();
+        assert_eq!(vec!['A'], check);
+    }
+    #[test]
+    fn test_try_from_range_inclusive_err() {
+        let check = UnicodeSet::try_from(&('B'..'A'));
+        assert_eq!(Err(USetError::InvalidRange(66, 65)), check);
+    }
+    #[test]
+    fn test_try_from_range_from() {
+        let uset = UnicodeSet::try_from(&('A'..)).unwrap();
+        let check: Vec<&u32> = uset.ranges().collect();
+        assert_eq!(vec![&65, &((std::char::MAX as u32) + 1)], check);
+    }
+    #[test]
+    fn test_try_from_range_to() {
+        let uset = UnicodeSet::try_from(&(..'A')).unwrap();
+        let check: Vec<&u32> = uset.ranges().collect();
+        assert_eq!(vec![&0, &65], check);
+    }
+    #[test]
+    fn test_try_from_range_to_err() {
+        let check = UnicodeSet::try_from(&(..(0 as char)));
+        assert_eq!(Err(USetError::InvalidRange(0, 0)), check);
+    }
+    #[test]
+    fn test_try_from_range_to_inclusive() {
+        let uset = UnicodeSet::try_from(&(..='A')).unwrap();
+        let check: Vec<&u32> = uset.ranges().collect();
+        assert_eq!(vec![&0, &66], check);
+    }
+    #[test]
+    fn test_try_from_range_full() {
+        let uset = UnicodeSet::try_from(&(..)).unwrap();
+        let check: Vec<&u32> = uset.ranges().collect();
+        assert_eq!(vec![&0, &((std::char::MAX as u32) + 1)], check);
+    }
+}

components/uniset/src/lib.rs

@@ -0,0 +1,15 @@
+#[macro_use]
+mod uniset;
+mod conversions;
+mod utils;
+
+pub use conversions::*;
+pub use uniset::UnicodeSet;
+pub use utils::*;
+
+/// Custom Errors for UnicodeSet.
+#[derive(Debug, PartialEq)]
+pub enum USetError {
+    InvalidSet(Vec<u32>),
+    InvalidRange(u32, u32),
+}