Struct eset::ESet

pub struct ESet<T: ReprEnum, const SEP: char = '|'>(/* private fields */);

An enum set for a fieldless enum T.

Operators

• !: bitwise not
• |: bitwise or, or union
• &: bitwise and, or intersection
• ^: bitwise xor, or exclusive or
• -: difference, a - b is equivalent to a ^ (a & b)
• +: alias for union

Operators are not availble to T by default unless T implements Into<ESet>. See derive_eset.

If the enum implements FromStr, this type provides parsing from CSV like syntax with a given SEP. You can use a crate like strum for this type of functionality.

If serde is enabled, ths type serializes into a CSV like string in human readable formats and its integer flags representation in non-human-readable formats.

While this type is perfectly usable, the user should alias this type ASAP with a fixed SEP for better ergonomics.

type Csv<T> = ESet<T, ','>;

This struct does not maintain the invarient that all bits correspond to valid T, instead invalid bits are ignored during iteration and parsing. This makes operations like bitwise not and binary serialization safe to do.

Implementations

impl<T: ReprEnum, const S: char> ESet<T, S>

pub const NONE: Self = _

The empty ESet.

pub fn new(item: T) -> Self

Create a new Eset from an single enum.

pub fn new_flags<TIter>(item: impl IntoIterator<Item = TIter>) -> Selfwhere Self: FromIterator<TIter>,

Create a new Eset from an iterator of enums.

pub fn is_empty(&self) -> bool

Check if the ESet is empty.

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

Check if the ESet contains a specific enum.

pub fn insert(&mut self, item: T) -> &mut Self

mutate the ESet by inserting an enum.

pub fn remove(&mut self, item: T) -> &mut Self

mutate the ESet by removing an enum.

pub fn with(self, item: T) -> Self

Create a new ESet by inserting an enum.

pub fn without(self, item: T) -> Self

Create a new ESet by removing an enum.

pub const fn with_separator<const SEP: char>(self) -> ESet<T, SEP>

Convert a ESet into one with a different separator.

pub fn iter(&self) -> ESetIter<T, S>

Iterate over enums in the ESet.

Trait Implementations

impl<T: ReprEnum, R: Into<Self>, const S: char> Add<R> for ESet<T, S>

type Output = ESet<T, '|'>

The resulting type after applying the + operator.

fn add(self, rhs: R) -> Self::Output

Performs the + operation.

impl<T: ReprEnum, R: Into<Self>, const S: char> AddAssign<R> for ESet<T, S>

fn add_assign(&mut self, rhs: R)

Performs the += operation.

impl<T: ReprEnum, R: Into<Self>, const S: char> BitAnd<R> for ESet<T, S>

type Output = ESet<T, '|'>

The resulting type after applying the & operator.

fn bitand(self, rhs: R) -> Self::Output

Performs the & operation.

impl<T: ReprEnum, R: Into<Self>, const S: char> BitAndAssign<R> for ESet<T, S>

fn bitand_assign(&mut self, rhs: R)

Performs the &= operation.

impl<T: ReprEnum, R: Into<Self>, const S: char> BitOr<R> for ESet<T, S>

type Output = ESet<T, '|'>

The resulting type after applying the | operator.

fn bitor(self, rhs: R) -> Self::Output

Performs the | operation.

impl<T: ReprEnum, R: Into<Self>, const S: char> BitOrAssign<R> for ESet<T, S>

fn bitor_assign(&mut self, rhs: R)

Performs the |= operation.

impl<T: ReprEnum, R: Into<Self>, const S: char> BitXor<R> for ESet<T, S>

type Output = ESet<T, '|'>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: R) -> Self::Output

Performs the ^ operation.

impl<T: ReprEnum, R: Into<Self>, const S: char> BitXorAssign<R> for ESet<T, S>

fn bitxor_assign(&mut self, rhs: R)

Performs the ^= operation.

impl<T: Clone + ReprEnum, const SEP: char> Clone for ESet<T, SEP>where T::FlagsRepr: Clone,

fn clone(&self) -> ESet<T, SEP>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, const S: char> Debug for ESet<T, S>where T: Debug + ReprEnum,

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

Formats the value using the given formatter.

impl<T: ReprEnum, const S: char> Default for ESet<T, S>

fn default() -> Self

Returns the “default value” for a type.

impl<T, const S: char> Display for ESet<T, S>where T: Display + ReprEnum,

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

Formats the value using the given formatter.

impl<'t, T, const S: char> FromIterator<&'t T> for ESet<T, S>where T: 't + Copy + ReprEnum,

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

Creates a value from an iterator.

impl<T: ReprEnum, const S: char> FromIterator<T> for ESet<T, S>

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

Creates a value from an iterator.

impl<T, const S: char> FromStr for ESet<T, S>where T: FromStr + ReprEnum,

type Err = <T as FromStr>::Err

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<T: Hash + ReprEnum, const SEP: char> Hash for ESet<T, SEP>where T::FlagsRepr: Hash,

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: ReprEnum, const S: char> IntoIterator for &ESet<T, S>

type Item = T

The type of the elements being iterated over.

type IntoIter = ESetIter<T, S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: ReprEnum, const S: char> IntoIterator for ESet<T, S>

type Item = T

The type of the elements being iterated over.

type IntoIter = ESetIter<T, S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: ReprEnum, const S: char> Not for ESet<T, S>

type Output = ESet<T, '|'>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T: ReprEnum, const S: char> PartialEq<ESet<T, S>> for ESet<T, S>

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

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

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

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

impl<T: ReprEnum, const S: char> PartialOrd<ESet<T, S>> for ESet<T, S>

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

== mean equal > means contains, < means contained by, otherwise None

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<T: ReprEnum, R: Into<Self>, const S: char> Sub<R> for ESet<T, S>

type Output = ESet<T, '|'>

The resulting type after applying the - operator.

fn sub(self, rhs: R) -> Self::Output

Performs the - operation.

impl<T: ReprEnum, R: Into<Self>, const S: char> SubAssign<R> for ESet<T, S>

fn sub_assign(&mut self, rhs: R)

Performs the -= operation.

impl<T: Copy + ReprEnum, const SEP: char> Copy for ESet<T, SEP>where T::FlagsRepr: Copy,