Struct Varflags

pub struct Varflags<E, B>(/* private fields */)
where
    E: Sized + Clone + TryFrom<Index<B>>,
    B: Bitset + Copy,
    B::Repr: From<E>;

Struct representing set over variants of some enum E implemented using bitworks bitset B.

Implementations

impl<E, B> Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>>, B: Bitset + Copy, B::Repr: From<E>,

pub const NONE: Self = _

Empty set of variants.

pub const ALL: Self = _

Set of variants containing every variant of E.

pub const fn _from_inner(bitset: B) -> Self

Constructs Varflags from the inner Bitset.

pub fn contains(&self, variant: &E) -> bool

Returns true, if self contains a variant.

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

Returns true, if self contains all variants of other.

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

Returns true, if both self and other share at least 1 variant.

pub fn variants<'a>(&'a self) -> impl Iterator<Item = E> + 'a

Returns iterator over variants contained in self.

Trait Implementations

impl<E, B> BitAnd<E> for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>>, B: Bitset + Copy, B::Repr: From<E>,

type Output = Varflags<E, B>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<E, B> BitAnd for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>>, B: Bitset + Copy, B::Repr: From<E>,

type Output = Varflags<E, B>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<E, B> BitAndAssign<E> for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>>, B: Bitset + Copy, B::Repr: From<E>,

fn bitand_assign(&mut self, rhs: E)

Performs the &= operation.

impl<E, B> BitAndAssign for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>>, B: Bitset + Copy, B::Repr: From<E>,

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<E, B> BitOr<E> for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>>, B: Bitset + Copy, B::Repr: From<E>,

type Output = Varflags<E, B>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<E, B> BitOr for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>>, B: Bitset + Copy, B::Repr: From<E>,

type Output = Varflags<E, B>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<E, B> BitOrAssign<E> for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>>, B: Bitset + Copy, B::Repr: From<E>,

fn bitor_assign(&mut self, rhs: E)

Performs the |= operation.

impl<E, B> BitOrAssign for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>>, B: Bitset + Copy, B::Repr: From<E>,

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<E, B> BitXor<E> for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>>, B: Bitset + Copy, B::Repr: From<E>,

type Output = Varflags<E, B>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<E, B> BitXor for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>>, B: Bitset + Copy, B::Repr: From<E>,

type Output = Varflags<E, B>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<E, B> BitXorAssign<E> for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>>, B: Bitset + Copy, B::Repr: From<E>,

fn bitxor_assign(&mut self, rhs: E)

Performs the ^= operation.

impl<E, B> BitXorAssign for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>>, B: Bitset + Copy, B::Repr: From<E>,

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<E, B> Clone for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>> + Clone, B: Bitset + Copy + Clone, B::Repr: From<E>,

fn clone(&self) -> Varflags<E, B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E, B> Debug for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>> + Display, B: Bitset + Copy, B::Repr: From<E>,

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

Formats the value using the given formatter.

impl<E, B> Display for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>> + Display, B: Bitset + Copy, B::Repr: From<E>,

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

Formats the value using the given formatter.

impl<E, B> FromIterator<E> for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>>, B: Bitset + Copy, B::Repr: From<E>,

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

Creates a value from an iterator.

impl<E, B> Hash for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>> + Hash, B: Bitset + Copy + Hash, B::Repr: From<E>,

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<E, B> Not for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>>, B: Bitset + Copy, B::Repr: From<E>,

type Output = Varflags<E, B>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<E, B> PartialEq for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>> + PartialEq, B: Bitset + Copy + PartialEq, B::Repr: From<E>,

fn eq(&self, other: &Varflags<E, B>) -> 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<E, B> Copy for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>> + Copy, B: Bitset + Copy + Copy, B::Repr: From<E>,

impl<E, B> Eq for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>> + Eq, B: Bitset + Copy + Eq, B::Repr: From<E>,

impl<E, B> StructuralPartialEq for Varflags<E, B>

where E: Sized + Clone + TryFrom<Index<B>>, B: Bitset + Copy, B::Repr: From<E>,