pub struct CodePointInversionList<'data> { /* private fields */ }
Expand description

A membership wrapper for CodePointInversionList.

Provides exposure to membership functions and constructors from serialized CodePointSets (sets of code points) and predefined ranges.

Implementations§

source§

impl<'data> CodePointInversionList<'data>

source

pub fn try_from_inversion_list( inv_list: ZeroVec<'data, PotentialCodePoint>, ) -> Result<CodePointInversionList<'data>, InvalidSetError>

Returns a new CodePointInversionList from an inversion list represented as a ZeroVec<PotentialCodePoint> of code points.

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::collections::codepointinvlist::CodePointInversionList;
use icu::collections::codepointinvlist::InvalidSetError;
use zerovec::ZeroVec;
use potential_utf::PotentialCodePoint;

let valid = [0x0, 0x10000];
let inv_list: ZeroVec<PotentialCodePoint> = valid.into_iter().map(PotentialCodePoint::from_u24).collect();
let result = CodePointInversionList::try_from_inversion_list(inv_list);
assert!(matches!(result, CodePointInversionList));

let invalid = vec![0x0, 0x80, 0x3];
let inv_list: ZeroVec<PotentialCodePoint> = invalid.iter().copied().map(PotentialCodePoint::from_u24).collect();
let result = CodePointInversionList::try_from_inversion_list(inv_list);
assert!(matches!(
    result,
    Err(InvalidSetError(_))
));
if let Err(InvalidSetError(actual)) = result {
    assert_eq!(&invalid, &actual.into_iter().map(u32::from).collect::<Vec<_>>());
}
source

pub fn try_from_u32_inversion_list_slice( inv_list: &[u32], ) -> Result<CodePointInversionList<'data>, InvalidSetError>

Returns a new, fully-owned CodePointInversionList by cloning an inversion list represented as a slice of PotentialCodePoint code points.

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::collections::codepointinvlist::CodePointInversionList;

let bmp_list = &[0x0, 0x10000];
let smp_list = &[0x10000, 0x20000];
let sip_list = &[0x20000, 0x30000];

let lists: Vec<CodePointInversionList> =
    [&bmp_list[..], smp_list, sip_list]
        .into_iter()
        .map(|l| {
            CodePointInversionList::try_from_u32_inversion_list_slice(l)
                .unwrap()
        })
        .collect();

let bmp = &lists[0];
assert!(bmp.contains32(0xFFFF));
assert!(!bmp.contains32(0x10000));

assert!(!lists.iter().any(|set| set.contains32(0x40000)));
source

pub fn into_owned(self) -> CodePointInversionList<'static>

Attempts to convert this list into a fully-owned one. No-op if already fully owned

source

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

Returns an owned inversion list representing the current CodePointInversionList

source

pub fn all() -> CodePointInversionList<'data>

Returns CodePointInversionList spanning entire Unicode range

The range spans from 0x0 -> 0x10FFFF inclusive.

§Examples
use icu::collections::codepointinvlist::CodePointInversionList;

let expected = [0x0, (char::MAX as u32) + 1];
assert_eq!(
    CodePointInversionList::all().get_inversion_list_vec(),
    expected
);
assert_eq!(
    CodePointInversionList::all().size(),
    (expected[1] - expected[0]) as usize
);
source

pub fn bmp() -> CodePointInversionList<'data>

Returns CodePointInversionList spanning BMP range

The range spans from 0x0 -> 0xFFFF inclusive.

§Examples
use icu::collections::codepointinvlist::CodePointInversionList;

const BMP_MAX: u32 = 0xFFFF;

let expected = [0x0, BMP_MAX + 1];
assert_eq!(
    CodePointInversionList::bmp().get_inversion_list_vec(),
    expected
);
assert_eq!(
    CodePointInversionList::bmp().size(),
    (expected[1] - expected[0]) as usize
);
source

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

Yields an Iterator going through the character set in the CodePointInversionList

§Examples
use icu::collections::codepointinvlist::CodePointInversionList;
let example_list = [0x41, 0x44, 0x45, 0x46];
let example =
    CodePointInversionList::try_from_u32_inversion_list_slice(&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());
source

pub fn iter_ranges(&self) -> impl ExactSizeIterator

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

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: CodePointInversionList::contains(UChar32 start, UChar32 end).

§Example
use icu::collections::codepointinvlist::CodePointInversionList;
let example_list = [0x41, 0x44, 0x45, 0x46];
let example =
    CodePointInversionList::try_from_u32_inversion_list_slice(&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());
source

pub fn iter_ranges_complemented( &self, ) -> impl Iterator<Item = RangeInclusive<u32>>

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

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: CodePointInversionList::contains(UChar32 start, UChar32 end).

§Example
use icu::collections::codepointinvlist::CodePointInversionList;
let example_list = [0x41, 0x44, 0x45, 0x46];
let example =
    CodePointInversionList::try_from_u32_inversion_list_slice(&example_list)
        .unwrap();
let mut example_iter_ranges = example.iter_ranges_complemented();
assert_eq!(Some(0..=0x40), example_iter_ranges.next());
assert_eq!(Some(0x44..=0x44), example_iter_ranges.next());
assert_eq!(Some(0x46..=char::MAX as u32), example_iter_ranges.next());
assert_eq!(None, example_iter_ranges.next());
source

pub fn get_range_count(&self) -> usize

Returns the number of ranges contained in this CodePointInversionList

source

pub fn get_nth_range(&self, idx: usize) -> Option<RangeInclusive<u32>>

Returns a specific range contained in this CodePointInversionList by index. Intended for use in FFI.

source

pub fn size(&self) -> usize

Returns the number of elements of the CodePointInversionList

source

pub fn is_empty(&self) -> bool

Returns whether or not the CodePointInversionList is empty

source

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

Checks to see the query is in the CodePointInversionList

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

§Examples
use icu::collections::codepointinvlist::CodePointInversionList;
let example_list = [0x41, 0x43, 0x44, 0x45];
let example =
    CodePointInversionList::try_from_u32_inversion_list_slice(&example_list)
        .unwrap();
assert!(example.contains('A'));
assert!(!example.contains('C'));
source

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

Checks to see the unsigned int is in the CodePointInversionList::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 core implementation

§Examples
use icu::collections::codepointinvlist::CodePointInversionList;
let example_list = [0x41, 0x43, 0x44, 0x45];
let example =
    CodePointInversionList::try_from_u32_inversion_list_slice(&example_list)
        .unwrap();
assert!(example.contains32(0x41));
assert!(!example.contains32(0x43));
source

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

Checks to see if the range is in the CodePointInversionList

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::collections::codepointinvlist::CodePointInversionList;
let example_list = [0x41, 0x43, 0x44, 0x45];
let example =
    CodePointInversionList::try_from_u32_inversion_list_slice(&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 CodePointInversionList 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 CodePointInversionList::contains(UChar32 start, UChar32 end) method differs by including the end boundary.

§Examples
use icu::collections::codepointinvlist::CodePointInversionList;
use std::char;
let check =
    char::from_u32(0xD7FE).unwrap()..char::from_u32(0xE001).unwrap();
let example_list = [0xD7FE, 0xD7FF, 0xE000, 0xE001];
let example =
    CodePointInversionList::try_from_u32_inversion_list_slice(&example_list)
        .unwrap();
assert!(!example.contains_range(check));
source

pub fn contains_set(&self, set: &CodePointInversionList<'data>) -> bool

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

§Examples
use icu::collections::codepointinvlist::CodePointInversionList;
let example_list = [0x41, 0x46, 0x55, 0x5B]; // A - E, U - Z
let example =
    CodePointInversionList::try_from_u32_inversion_list_slice(&example_list)
        .unwrap();
let a_to_d =
    CodePointInversionList::try_from_u32_inversion_list_slice(&[0x41, 0x45])
        .unwrap();
let f_to_t =
    CodePointInversionList::try_from_u32_inversion_list_slice(&[0x46, 0x55])
        .unwrap();
let r_to_x =
    CodePointInversionList::try_from_u32_inversion_list_slice(&[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
source

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::collections::codepointinvlist::CodePointInversionList;
let example_list = [0x41, 0x44]; // {A, B, C}
let example =
    CodePointInversionList::try_from_u32_inversion_list_slice(&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);
source

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::collections::codepointinvlist::CodePointInversionList;
let example_list = [0x41, 0x44]; // {A, B, C}
let example =
    CodePointInversionList::try_from_u32_inversion_list_slice(&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§

source§

impl Bake for CodePointInversionList<'_>

source§

fn bake(&self, env: &CrateEnv) -> TokenStream

Returns a TokenStream that would evaluate to self. Read more
source§

impl BakeSize for CodePointInversionList<'_>

source§

fn borrows_size(&self) -> usize

Returns the size
source§

impl<'data> Clone for CodePointInversionList<'data>

source§

fn clone(&self) -> CodePointInversionList<'data>

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl<'data> Debug for CodePointInversionList<'data>

source§

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

Formats the value using the given formatter. Read more
source§

impl<'de, 'a> Deserialize<'de> for CodePointInversionList<'a>
where 'de: 'a,

source§

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

Deserialize this value from the given Serde deserializer. Read more
source§

impl<'data> EncodeAsVarULE<CodePointInversionListULE> for &CodePointInversionList<'data>

source§

fn encode_var_ule_as_slices<R>(&self, cb: impl FnOnce(&[&[u8]]) -> R) -> R

Calls cb with a piecewise list of byte slices that when concatenated produce the memory pattern of the corresponding instance of T. Read more
source§

fn encode_var_ule_len(&self) -> usize

Return the length, in bytes, of the corresponding VarULE type
source§

fn encode_var_ule_write(&self, dst: &mut [u8])

Write the corresponding VarULE type to the dst buffer. dst should be the size of Self::encode_var_ule_len()
source§

impl<'data> EncodeAsVarULE<CodePointInversionListULE> for CodePointInversionList<'data>

source§

fn encode_var_ule_as_slices<R>(&self, cb: impl FnOnce(&[&[u8]]) -> R) -> R

Calls cb with a piecewise list of byte slices that when concatenated produce the memory pattern of the corresponding instance of T. Read more
source§

fn encode_var_ule_len(&self) -> usize

Return the length, in bytes, of the corresponding VarULE type
source§

fn encode_var_ule_write(&self, dst: &mut [u8])

Write the corresponding VarULE type to the dst buffer. dst should be the size of Self::encode_var_ule_len()
source§

impl<'data> From<&'data CodePointInversionListULE> for CodePointInversionList<'data>

source§

fn from( other: &'data CodePointInversionListULE, ) -> CodePointInversionList<'data>

Converts to this type from the input type.
source§

impl FromIterator<RangeInclusive<u32>> for CodePointInversionList<'_>

source§

fn from_iter<I>(iter: I) -> CodePointInversionList<'_>
where I: IntoIterator<Item = RangeInclusive<u32>>,

Creates a value from an iterator. Read more
source§

impl<'data> PartialEq for CodePointInversionList<'data>

source§

fn eq(&self, other: &CodePointInversionList<'data>) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl Serialize for CodePointInversionList<'_>

source§

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

Serialize this value into the given Serde serializer. Read more
source§

impl TryFrom<Range<char>> for CodePointInversionList<'_>

source§

type Error = RangeError

The type returned in the event of a conversion error.
source§

fn try_from( range: Range<char>, ) -> Result<CodePointInversionList<'_>, <CodePointInversionList<'_> as TryFrom<Range<char>>>::Error>

Performs the conversion.
source§

impl TryFrom<RangeFrom<char>> for CodePointInversionList<'_>

source§

type Error = RangeError

The type returned in the event of a conversion error.
source§

fn try_from( range: RangeFrom<char>, ) -> Result<CodePointInversionList<'_>, <CodePointInversionList<'_> as TryFrom<RangeFrom<char>>>::Error>

Performs the conversion.
source§

impl TryFrom<RangeFull> for CodePointInversionList<'_>

source§

type Error = RangeError

The type returned in the event of a conversion error.
source§

fn try_from( _: RangeFull, ) -> Result<CodePointInversionList<'_>, <CodePointInversionList<'_> as TryFrom<RangeFull>>::Error>

Performs the conversion.
source§

impl TryFrom<RangeInclusive<char>> for CodePointInversionList<'_>

source§

type Error = RangeError

The type returned in the event of a conversion error.
source§

fn try_from( range: RangeInclusive<char>, ) -> Result<CodePointInversionList<'_>, <CodePointInversionList<'_> as TryFrom<RangeInclusive<char>>>::Error>

Performs the conversion.
source§

impl TryFrom<RangeTo<char>> for CodePointInversionList<'_>

source§

type Error = RangeError

The type returned in the event of a conversion error.
source§

fn try_from( range: RangeTo<char>, ) -> Result<CodePointInversionList<'_>, <CodePointInversionList<'_> as TryFrom<RangeTo<char>>>::Error>

Performs the conversion.
source§

impl TryFrom<RangeToInclusive<char>> for CodePointInversionList<'_>

source§

type Error = RangeError

The type returned in the event of a conversion error.
source§

fn try_from( range: RangeToInclusive<char>, ) -> Result<CodePointInversionList<'_>, <CodePointInversionList<'_> as TryFrom<RangeToInclusive<char>>>::Error>

Performs the conversion.
source§

impl<'a> Yokeable<'a> for CodePointInversionList<'static>

source§

type Output = CodePointInversionList<'a>

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

fn transform( &'a self, ) -> &'a <CodePointInversionList<'static> as Yokeable<'a>>::Output

This method must cast self between &'a Self<'static> and &'a Self<'a>. Read more
source§

fn transform_owned( self, ) -> <CodePointInversionList<'static> as Yokeable<'a>>::Output

This method must cast self between Self<'static> and Self<'a>. Read more
source§

unsafe fn make( this: <CodePointInversionList<'static> as Yokeable<'a>>::Output, ) -> CodePointInversionList<'static>

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

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

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

impl<'data> ZeroFrom<'data, CodePointInversionListULE> for CodePointInversionList<'data>

source§

fn zero_from( other: &'data CodePointInversionListULE, ) -> CodePointInversionList<'data>

Clone the other C into a struct that may retain references into C.
source§

impl<'zf, 'zf_inner> ZeroFrom<'zf, CodePointInversionList<'zf_inner>> for CodePointInversionList<'zf>

source§

fn zero_from( this: &'zf CodePointInversionList<'zf_inner>, ) -> CodePointInversionList<'zf>

Clone the other C into a struct that may retain references into C.
source§

impl<'data> Eq for CodePointInversionList<'data>

source§

impl<'data> StructuralPartialEq for CodePointInversionList<'data>

Auto Trait Implementations§

§

impl<'data> Freeze for CodePointInversionList<'data>

§

impl<'data> RefUnwindSafe for CodePointInversionList<'data>

§

impl<'data> Send for CodePointInversionList<'data>

§

impl<'data> Sync for CodePointInversionList<'data>

§

impl<'data> Unpin for CodePointInversionList<'data>

§

impl<'data> UnwindSafe for CodePointInversionList<'data>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

impl<T> Serialize for T
where T: Serialize + ?Sized,

source§

fn erased_serialize(&self, serializer: &mut dyn Serializer) -> Result<Ok, Error>

source§

impl<T> ToOwned for T
where T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,

source§

impl<T> ErasedDestructor for T
where T: 'static,

source§

impl<T> MaybeSendSync for T
where T: Send + Sync,