Struct Set

pub struct Set<'a, T>(/* private fields */);

Set objects represent a mathematical set of integer values.

Sets are used in non-shaping APIs to query certain sets of characters or glyphs, or other integer values.

Implementations

impl<T> Set<'static, T>

pub fn new() -> Result<Self, AllocationError>

Creates a new, initially empty set.

impl<'a, T> Set<'a, T>

pub fn is_empty(&self) -> bool

Tests whether set is empty i.e. contains no elements.

pub fn len(&self) -> usize

Returns the number of elements in the set.

Note that this returns the number of elements in the underlying raw set over u32, not the number of elements that can be represented as T. This is especially evident when the set is over chars and invalid code points have been added with Self::insert_range.

let mut set = CharSet::new()?;
set.insert_range('\u{D7FF}'..'\u{E000}'); // Add all surrogate pairs (and \u{D7FF} for technical reasons)
assert_eq!(set.len(), 2049);

pub fn clear(&mut self)

Clears out the contents of a set.

pub fn copy_from(&mut self, other: &Self)

Makes the contents of self equal to the contents of other.

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

Tests whether self contains other set.

pub fn clone_static(&self) -> Set<'static, T>

Constructs a copy of the set with 'static lifetime.

impl<'a, T> Set<'a, T>

where T: Into<u32>,

pub fn contains(&self, value: T) -> bool

Tests whether a value belongs to set.

pub fn insert(&mut self, value: T)

Inserts a value to set.

Panics

Will panic if value is sys::HB_SET_VALUE_INVALID.

pub fn remove(&mut self, value: T)

Removes a value from set.

pub fn insert_range(&mut self, range: impl RangeBounds<T>)

where T: Clone + 'static,

Inserts a range of values to set.

Panics

Will panic if range explicitly contains sys::HB_SET_VALUE_INVALID:

U32Set::new()?.insert_range(u32::MAX-10..=u32::MAX);

These still work:

U32Set::new()?.insert_range(u32::MAX-10..);
U32Set::new()?.insert_range(u32::MAX-10..u32::MAX);

pub fn remove_range(&mut self, range: impl RangeBounds<T>)

where T: Clone + 'static,

Removes a range of values from set.

impl<'a, T> Set<'a, T>

where T: TryFrom<u32>,

pub fn iter(&self) -> SetIter<'_, 'a, T>

Constructs an iterator over the set.

impl<'a, T> Set<'a, T>

pub fn into_raw(self) -> *mut hb_set_t

Converts the set into raw sys::hb_set_t pointer.

This method transfers the ownership of the set to the caller. It is up to the caller to call sys::hb_set_destroy to free the pointer, or call Self::from_raw to convert it back into Set.

pub fn as_raw(&self) -> *mut hb_set_t

Exposes the raw inner pointer without transferring the ownership.

Unlike Self::into_raw, this method does not transfer the ownership of the pointer to the caller.

pub unsafe fn from_raw(set: *mut hb_set_t) -> Self

Constructs a set from raw sys::hb_set_t pointer.

Safety

The given set pointer must either be constructed by some Harfbuzz function, or be returned from Self::into_raw.

Trait Implementations

impl<'a, T> Clone for Set<'a, T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, T> Debug for Set<'a, T>

where T: TryFrom<u32> + Debug,

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

Formats the value using the given formatter.

impl<'a, T> FromIterator<T> for Set<'a, T>

where T: Into<u32>,

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, T> Hash for Set<'a, T>

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'s, 'a, T> IntoIterator for &'s Set<'a, T>

where T: TryFrom<u32>,

type Item = T

The type of the elements being iterated over.

type IntoIter = SetIter<'s, 'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> PartialEq for Set<'a, T>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'a, T> Eq for Set<'a, T>

where T: Eq,