Struct icu_uniset::UnicodeSet

pub struct UnicodeSet { /* fields omitted */ }

A membership wrapper for UnicodeSet.

Provides exposure to membership functions and constructors from serialized UnicodeSets and predefined ranges.

Implementations

impl UnicodeSet

pub fn from_inversion_list(inv_list: Vec<u32>) -> Result<Self, UnicodeSetError>

Returns UnicodeSet from an inversion list. represented by a Vec<u32> of codepoints.

The inversion list must be of even length, sorted ascending non-overlapping, and within the bounds of 0x0 -> 0x10FFFF inclusive, and end points being exclusive.

Examples

use icu::uniset::UnicodeSet;
use icu::uniset::UnicodeSetError;
let invalid: Vec<u32> = vec![0x0, 0x80, 0x3];
let result = UnicodeSet::from_inversion_list(invalid.clone());
assert!(matches!(result, Err(UnicodeSetError::InvalidSet(_))));
if let Err(UnicodeSetError::InvalidSet(actual)) = result {
    assert_eq!(invalid, actual);
}

pub fn get_inversion_list(&self) -> Vec<u32>

Returns an owned inversion list representing the current UnicodeSet

pub fn all() -> Self

Returns UnicodeSet spanning entire Unicode range

The range spans from 0x0 -> 0x10FFFF inclusive

pub fn bmp() -> Self

Returns UnicodeSet spanning BMP range

The range spans from 0x0 -> 0xFFFF inclusive

pub fn iter_chars(&self) -> impl Iterator<Item = char> + '_

Yields an Iterator going through the character set in the UnicodeSet

Examples

use icu::uniset::UnicodeSet;
let example_list = vec![0x41, 0x44, 0x45, 0x46];
let example = UnicodeSet::from_inversion_list(example_list).unwrap();
let mut ex_iter_chars = example.iter_chars();
assert_eq!(Some('A'), ex_iter_chars.next());
assert_eq!(Some('B'), ex_iter_chars.next());
assert_eq!(Some('C'), ex_iter_chars.next());
assert_eq!(Some('E'), ex_iter_chars.next());
assert_eq!(None, ex_iter_chars.next());

pub fn iter_ranges(
    &self
) -> impl ExactSizeIterator<Item = RangeInclusive<u32>> + '_

Yields an Iterator returning the ranges of the code points that are included in the UnicodeSet

Ranges are returned as RangeInclusive, which is inclusive of its end bound value. An end-inclusive behavior matches the ICU4C/J behavior of ranges, ex: UnicodeSet::contains(UChar32 start, UChar32 end).

Example

use icu::uniset::UnicodeSet;
let example_list = vec![0x41, 0x44, 0x45, 0x46];
let example = UnicodeSet::from_inversion_list(example_list).unwrap();
let mut example_iter_ranges = example.iter_ranges();
assert_eq!(Some(0x41..=0x43), example_iter_ranges.next());
assert_eq!(Some(0x45..=0x45), example_iter_ranges.next());
assert_eq!(None, example_iter_ranges.next());

pub fn get_range_count(&self) -> usize

Returns the number of ranges contained in this UnicodeSet

pub fn size(&self) -> usize

Returns the number of elements of the UnicodeSet

pub fn is_empty(&self) -> bool

Returns whether or not the UnicodeSet is empty

pub fn contains(&self, query: char) -> bool

Checks to see the query is in the UnicodeSet

Runs a binary search in O(log(n)) where n is the number of start and end points in the set using std implementation

Examples

use icu::uniset::UnicodeSet;
let example_list = vec![0x41, 0x43, 0x44, 0x45];
let example = UnicodeSet::from_inversion_list(example_list).unwrap();
assert!(example.contains('A'));
assert!(!example.contains('C'));

pub fn contains_u32(&self, query: u32) -> bool

Checks to see the unsigned int is in the UnicodeSet::all()

Note: Even though u32 and char in Rust are non-negative 4-byte values, there is an important difference. A u32 can take values up to a very large integer value, while a char in Rust is defined to be in the range from 0 to the maximum valid Unicode Scalar Value.

Runs a binary search in O(log(n)) where n is the number of start and end points in the set using std implementation

Examples

use icu::uniset::UnicodeSet;
let example_list = vec![0x41, 0x43, 0x44, 0x45];
let example = UnicodeSet::from_inversion_list(example_list).unwrap();
assert!(example.contains_u32(0x41));
assert!(!example.contains_u32(0x43));

pub fn contains_range(&self, range: &impl RangeBounds<char>) -> bool

Checks to see if the range is in the UnicodeSet, returns a Result

Runs a binary search in O(log(n)) where n is the number of start and end points in the set using Vec implementation. Only runs the search once on the start parameter, while the end parameter is checked in a single O(1) step.

Examples

use icu::uniset::UnicodeSet;
let example_list = vec![0x41, 0x43, 0x44, 0x45];
let example = UnicodeSet::from_inversion_list(example_list).unwrap();
assert!(example.contains_range(&('A'..'C')));
assert!(example.contains_range(&('A'..='B')));
assert!(!example.contains_range(&('A'..='C')));

Surrogate points (0xD800 -> 0xDFFF) will return false if the Range contains them but the UnicodeSet does not.

Note: when comparing to ICU4C/J, keep in mind that Ranges in Rust are constructed inclusive of start boundary and exclusive of end boundary. The ICU4C/J UnicodeSet::contains(UChar32 start, UChar32 end) method differs by including the end boundary.

Examples

use icu::uniset::UnicodeSet;
use std::char;
let check = char::from_u32(0xD7FE).unwrap() .. char::from_u32(0xE001).unwrap();
let example_list = vec![0xD7FE, 0xD7FF, 0xE000, 0xE001];
let example = UnicodeSet::from_inversion_list(example_list).unwrap();
assert!(!example.contains_range(&(check)));

pub fn contains_set(&self, set: &Self) -> bool

Check if the calling UnicodeSet contains all the characters of the given UnicodeSet

Examples

use icu::uniset::UnicodeSet;
let example_list = vec![0x41, 0x46, 0x55, 0x5B]; // A - E, U - Z
let example = UnicodeSet::from_inversion_list(example_list).unwrap();
let a_to_d = UnicodeSet::from_inversion_list(vec![0x41, 0x45]).unwrap();
let f_to_t = UnicodeSet::from_inversion_list(vec![0x46, 0x55]).unwrap();
let r_to_x = UnicodeSet::from_inversion_list(vec![0x52, 0x58]).unwrap();
assert!(example.contains_set(&a_to_d)); // contains all
assert!(!example.contains_set(&f_to_t)); // contains none
assert!(!example.contains_set(&r_to_x)); // contains some

pub fn span(&self, span_str: &str, contained: bool) -> usize

Returns the end of the initial substring where the characters are either contained/not contained in the set.

Examples

use icu::uniset::UnicodeSet;
let example_list = vec![0x41, 0x44]; // {A, B, C}
let example = UnicodeSet::from_inversion_list(example_list).unwrap();
assert_eq!(example.span("CABXYZ", true), 3);
assert_eq!(example.span("XYZC", false), 3);
assert_eq!(example.span("XYZ", true), 0);
assert_eq!(example.span("ABC", false), 0);

pub fn span_back(&self, span_str: &str, contained: bool) -> usize

Returns the start of the trailing substring (starting from end of string) where the characters are either contained/not contained in the set. Returns the length of the string if no valid return.

Examples

use icu::uniset::UnicodeSet;
let example_list = vec![0x41, 0x44]; // {A, B, C}
let example = UnicodeSet::from_inversion_list(example_list).unwrap();
assert_eq!(example.span_back("XYZCAB", true), 3);
assert_eq!(example.span_back("ABCXYZ", true), 6);
assert_eq!(example.span_back("CABXYZ", false), 3);

Trait Implementations

impl Clone for UnicodeSet

fn clone(&self) -> UnicodeSet

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for UnicodeSet

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for UnicodeSet

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Hash for UnicodeSet

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<UnicodeSet> for UnicodeSet

fn eq(&self, other: &UnicodeSet) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &UnicodeSet) -> bool

This method tests for !=.

impl Serialize for UnicodeSet

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl TryFrom<&'_ Range<char>> for UnicodeSet

type Error = UnicodeSetError

The type returned in the event of a conversion error.

fn try_from(range: &Range<char>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&'_ RangeFrom<char>> for UnicodeSet

type Error = UnicodeSetError

The type returned in the event of a conversion error.

fn try_from(range: &RangeFrom<char>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&'_ RangeFull> for UnicodeSet

type Error = UnicodeSetError

The type returned in the event of a conversion error.

fn try_from(_: &RangeFull) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&'_ RangeInclusive<char>> for UnicodeSet

type Error = UnicodeSetError

The type returned in the event of a conversion error.

fn try_from(range: &RangeInclusive<char>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&'_ RangeTo<char>> for UnicodeSet

type Error = UnicodeSetError

The type returned in the event of a conversion error.

fn try_from(range: &RangeTo<char>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&'_ RangeToInclusive<char>> for UnicodeSet

type Error = UnicodeSetError

The type returned in the event of a conversion error.

fn try_from(range: &RangeToInclusive<char>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'data> TryInto<UnicodeSet> for UnicodePropertyV1<'data>

type Error = UnicodeSetError

The type returned in the event of a conversion error.

fn try_into(self) -> Result<UnicodeSet, Self::Error>

Performs the conversion.

impl<'a> Yokeable<'a> for UnicodeSet

type Output = Self

This type MUST be Self with the 'static replaced with 'a, i.e. Self<'a>

fn transform(&self) -> &Self::Output

This method must cast self between &'a Self<'static> and &'a Self<'a>.

fn transform_owned(self) -> Self::Output

This method must cast self between Self<'static> and Self<'a>.

unsafe fn make(this: Self::Output) -> Self

This method can be used to cast away Self<'a>’s lifetime.

fn transform_mut<F>(&'a mut self, f: F) where
    F: 'static + for<'b> FnOnce(&'b mut Self::Output), 

This method must cast self between &'a mut Self<'static> and &'a mut Self<'a>, and pass it to f.

impl ZeroCopyFrom<UnicodeSet> for UnicodeSet

fn zero_copy_from(this: &Self) -> Self

Clone the cart C into a [Yokeable] struct, which may retain references into C.

impl Eq for UnicodeSet

impl StructuralEq for UnicodeSet

impl StructuralPartialEq for UnicodeSet