Struct MixedEnumSet 

pub struct MixedEnumSet<T: EnumSetTypeWithRepr> { /* private fields */ }

A variant of EnumSet that preserves unknown bits.

It only works for enums with an #[enumset(repr = "…")] attribute used with a primitive integer type.

Numeric Representation

MixedEnumSet uses the same underlying numeric representation as EnumSet. However, bits that do not correspond to an enum variant can be set.

Serialization

When the serde feature is enabled, MixedEnumSets can be serialized and deserialized using the serde crate. It is always serialized as a single integer of the underlying repr type.

Unlike EnumSet, it ignores all flags given to EnumSetType.

FFI Safety

MixedEnumSet may be used interchangeably with the specified repr type in FFI.

Implementations

impl<T: EnumSetTypeWithRepr> MixedEnumSet<T>

pub const fn new() -> Self

Creates an empty MixedEnumSet.

pub const fn empty() -> Self

Creates an empty MixedEnumSet.

This is an alias for MixedEnumSet::new.

pub const fn all() -> Self

Returns a MixedEnumSet containing all valid variants of the enum.

pub const fn variant_count() -> u32

The number of valid variants that this type can contain.

pub fn only(t: T) -> Self

Returns a set containing a single element.

pub fn bit_index(t: T) -> u32

Returns the bit a given enum variant is stored in.

If this returns n, it means the bit is stored in the n + 1th least significant bit of the underlying integer, corresponding to a mask of 1 << n.

pub fn is_bit_valid(bit: u32) -> bool

Returns whether a given bit is valid for this set.

pub fn len(&self) -> usize

Returns the number of elements in this set.

pub fn is_empty(&self) -> bool

Returns true if the set contains no elements.

pub fn clear(&mut self)

Removes all elements from the set.

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

Checks whether this set contains a value.

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

Adds a value to this set.

If the set did not have this value present, true is returned.

If the set did have this value present, false is returned.

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

Removes a value from this set. Returns whether the value was present in the set.

pub fn is_disjoint(&self, other: impl Into<Self>) -> bool

Returns true if self has no elements in common with other. This is equivalent to checking for an empty intersection.

pub fn is_superset(&self, other: impl Into<Self>) -> bool

Returns true if the set is a superset of another, i.e., self contains at least all the values in other.

pub fn is_subset(&self, other: impl Into<Self>) -> bool

Returns true if the set is a subset of another, i.e., other contains at least all the values in self.

pub fn union(&self, other: impl Into<Self>) -> Self

Returns a set containing any elements present in either set.

pub fn intersection(&self, other: impl Into<Self>) -> Self

Returns a set containing every element present in both sets.

pub fn difference(&self, other: impl Into<Self>) -> Self

Returns a set containing every element present in self but not in other.

pub fn symmetric_difference(&self, other: impl Into<Self>) -> Self

Returns a set containing every element present in either self or other, but not present in both.

pub fn symmetrical_difference(&self, other: impl Into<Self>) -> Self

👎Deprecated since 1.1.13:

use symmetric_difference instead

Returns a set containing every element present in either self or other, but not present in both.

This is a legacy name for this function, and should not be used.

pub fn complement(&self) -> Self

Returns a set containing all enum variants not in this set.

This method clears any unknown bits already existing in the set.

pub fn full_complement(&self) -> Self

Returns a set containing all bits not in this set.

This method sets any unknown bits not already existing in the set.

pub fn valid_len(&self) -> usize

Returns the number of elements in this set, excluding unknown bits.

pub fn has_unknown_bits(&self) -> bool

Returns whether this bitset contains any bits that do not correspond to a valid variant.

pub fn has_bit(&self, value: u32) -> bool

Checks whether this set contains a specific bit.

pub fn insert_bit(&mut self, value: u32) -> bool

Adds a specific bit to this set.

If the set did not have this bit present, true is returned.

If the set did have this bit present, false is returned.

pub fn remove_bit(&mut self, value: u32) -> bool

Removes a specific bit from this set. Returns whether the bit was present in the set.

pub fn insert_all(&mut self, other: impl Into<Self>)

Adds all elements in another set to this one.

pub fn remove_all(&mut self, other: impl Into<Self>)

Removes all values in another set from this one.

impl<T: EnumSetTypeWithRepr> MixedEnumSet<T>

pub const fn as_repr(&self) -> <T as EnumSetTypeWithRepr>::Repr

Returns a T::Repr representing the elements of this set.

Unlike the other as_* methods, this method is zero-cost and guaranteed not to fail, panic or truncate any bits.

pub fn from_repr(bits: <T as EnumSetTypeWithRepr>::Repr) -> Self

Constructs a bitset from a T::Repr.

pub fn from_repr_truncated(bits: <T as EnumSetTypeWithRepr>::Repr) -> Self

Constructs a bitset from a T::Repr, ignoring invalid variants.

pub fn as_enumset(&self) -> EnumSet<T>

Converts this set into the corresponding EnumSet.

If any unknown bits are present in the set, this method will panic.

pub fn try_as_enumset(&self) -> Option<EnumSet<T>>

Attempts to convert this set into the corresponding EnumSet.

If any unknown bits are present in the set, this method will return None.

pub fn as_enumset_truncate(&self) -> EnumSet<T>

Converts this set into the corresponding EnumSet, ignoring bits that do not correspond to a variant.

impl<T: EnumSetTypeWithRepr> MixedEnumSet<T>

pub fn iter(&self) -> MixedEnumSetIter<T>

Iterates the contents of the set in order from the least significant bit to the most significant bit.

Note that iterator invalidation is impossible as the iterator contains a copy of this type, rather than holding a reference to it.

Trait Implementations

impl<T: EnumSetTypeWithRepr, O: Into<MixedEnumSet<T>>> BitAnd<O> for MixedEnumSet<T>

type Output = MixedEnumSet<T>

The resulting type after applying the & operator.

fn bitand(self, other: O) -> Self::Output

Performs the & operation.

impl<T: EnumSetTypeWithRepr, O: Into<MixedEnumSet<T>>> BitAndAssign<O> for MixedEnumSet<T>

fn bitand_assign(&mut self, rhs: O)

Performs the &= operation.

impl<T: EnumSetTypeWithRepr, O: Into<MixedEnumSet<T>>> BitOr<O> for MixedEnumSet<T>

type Output = MixedEnumSet<T>

The resulting type after applying the | operator.

fn bitor(self, other: O) -> Self::Output

Performs the | operation.

impl<T: EnumSetTypeWithRepr, O: Into<MixedEnumSet<T>>> BitOrAssign<O> for MixedEnumSet<T>

fn bitor_assign(&mut self, rhs: O)

Performs the |= operation.

impl<T: EnumSetTypeWithRepr, O: Into<MixedEnumSet<T>>> BitXor<O> for MixedEnumSet<T>

type Output = MixedEnumSet<T>

The resulting type after applying the ^ operator.

fn bitxor(self, other: O) -> Self::Output

Performs the ^ operation.

impl<T: EnumSetTypeWithRepr, O: Into<MixedEnumSet<T>>> BitXorAssign<O> for MixedEnumSet<T>

fn bitxor_assign(&mut self, rhs: O)

Performs the ^= operation.

impl<T: Clone + EnumSetTypeWithRepr> Clone for MixedEnumSet<T>

fn clone(&self) -> MixedEnumSet<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy + EnumSetTypeWithRepr> Copy for MixedEnumSet<T>

impl<T: EnumSetTypeWithRepr + Debug> Debug for MixedEnumSet<T>

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

Formats the value using the given formatter.

impl<T: EnumSetTypeWithRepr> Default for MixedEnumSet<T>

fn default() -> Self

Returns an empty set.

impl<T: EnumSetTypeWithRepr + Display> Display for MixedEnumSet<T>

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

Formats the value using the given formatter.

impl<T: Eq + EnumSetTypeWithRepr> Eq for MixedEnumSet<T>

impl<'a, T: EnumSetTypeWithRepr> Extend<&'a EnumSet<T>> for MixedEnumSet<T>

fn extend<I: IntoIterator<Item = &'a EnumSet<T>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, T: EnumSetTypeWithRepr> Extend<&'a MixedEnumSet<T>> for MixedEnumSet<T>

fn extend<I: IntoIterator<Item = &'a MixedEnumSet<T>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, T: EnumSetTypeWithRepr> Extend<&'a T> for MixedEnumSet<T>

fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T: EnumSetTypeWithRepr> Extend<EnumSet<T>> for MixedEnumSet<T>

fn extend<I: IntoIterator<Item = EnumSet<T>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T: EnumSetTypeWithRepr> Extend<MixedEnumSet<T>> for MixedEnumSet<T>

fn extend<I: IntoIterator<Item = MixedEnumSet<T>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T: EnumSetTypeWithRepr> Extend<T> for MixedEnumSet<T>

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T: EnumSetTypeWithRepr> From<EnumSet<T>> for MixedEnumSet<T>

fn from(value: EnumSet<T>) -> Self

Converts to this type from the input type.

impl<T: EnumSetTypeWithRepr> From<T> for MixedEnumSet<T>

fn from(t: T) -> Self

Converts to this type from the input type.

impl<T: EnumSetTypeWithRepr, const N: usize> From<[T; N]> for MixedEnumSet<T>

fn from(value: [T; N]) -> Self

Converts to this type from the input type.

impl<'a, T: 'a + EnumSetTypeWithRepr> FromIterator<&'a EnumSet<T>> for MixedEnumSet<T>

fn from_iter<I: IntoIterator<Item = &'a EnumSet<T>>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, T: 'a + EnumSetTypeWithRepr> FromIterator<&'a MixedEnumSet<T>> for MixedEnumSet<T>

fn from_iter<I: IntoIterator<Item = &'a MixedEnumSet<T>>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, T: 'a + EnumSetTypeWithRepr> FromIterator<&'a T> for MixedEnumSet<T>

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

Creates a value from an iterator.

impl<T: EnumSetTypeWithRepr> FromIterator<EnumSet<T>> for MixedEnumSet<T>

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

Creates a value from an iterator.

impl<T: EnumSetTypeWithRepr> FromIterator<MixedEnumSet<T>> for MixedEnumSet<T>

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

Creates a value from an iterator.

impl<T: EnumSetTypeWithRepr> FromIterator<T> for MixedEnumSet<T>

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

Creates a value from an iterator.

impl<T: EnumSetTypeWithRepr> Hash for MixedEnumSet<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<T: EnumSetTypeWithRepr> IntoIterator for MixedEnumSet<T>

type Item = MixedValue<T>

The type of the elements being iterated over.

type IntoIter = MixedEnumSetIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: EnumSetTypeWithRepr> Not for MixedEnumSet<T>

type Output = MixedEnumSet<T>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T: EnumSetTypeWithRepr> Ord for MixedEnumSet<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq + EnumSetTypeWithRepr> PartialEq for MixedEnumSet<T>

fn eq(&self, other: &MixedEnumSet<T>) -> 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<T: EnumSetTypeWithRepr> PartialEq<EnumSet<T>> for MixedEnumSet<T>

fn eq(&self, other: &EnumSet<T>) -> 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<T: EnumSetTypeWithRepr> PartialEq<MixedEnumSet<T>> for EnumSet<T>

fn eq(&self, other: &MixedEnumSet<T>) -> 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<T: EnumSetTypeWithRepr> PartialEq<T> for MixedEnumSet<T>

fn eq(&self, other: &T) -> 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<T: EnumSetTypeWithRepr> PartialOrd for MixedEnumSet<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: PartialEq + EnumSetTypeWithRepr> StructuralPartialEq for MixedEnumSet<T>

impl<T: EnumSetTypeWithRepr, O: Into<MixedEnumSet<T>>> Sub<O> for MixedEnumSet<T>

type Output = MixedEnumSet<T>

The resulting type after applying the - operator.

fn sub(self, other: O) -> Self::Output

Performs the - operation.

impl<T: EnumSetTypeWithRepr, O: Into<MixedEnumSet<T>>> SubAssign<O> for MixedEnumSet<T>

fn sub_assign(&mut self, rhs: O)

Performs the -= operation.

impl<T: EnumSetTypeWithRepr> Sum for MixedEnumSet<T>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, T: EnumSetTypeWithRepr> Sum<&'a EnumSet<T>> for MixedEnumSet<T>

fn sum<I: Iterator<Item = &'a EnumSet<T>>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, T: EnumSetTypeWithRepr> Sum<&'a MixedEnumSet<T>> for MixedEnumSet<T>

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, T: EnumSetTypeWithRepr> Sum<&'a T> for MixedEnumSet<T>

fn sum<I: Iterator<Item = &'a T>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, T: EnumSetTypeWithRepr> Sum<EnumSet<T>> for MixedEnumSet<T>

fn sum<I: Iterator<Item = EnumSet<T>>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T: EnumSetTypeWithRepr> Sum<T> for MixedEnumSet<T>

fn sum<I: Iterator<Item = T>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.