Struct enumflags2::BitFlags

#[repr(transparent)]
pub struct BitFlags<T: RawBitFlags> { /* fields omitted */ }

Represents a set of flags of some type T. The type must have the #[derive(BitFlags)] attribute applied.

Implementations

impl<T> BitFlags<T> where
    T: RawBitFlags, 

pub unsafe fn new(val: T::Type) -> Self

Create a new BitFlags unsafely, without checking if the bits form a valid bit pattern for the type.

Consider using from_bits or from_bits_truncate instead.

Safety

The argument must not have set bits at positions not corresponding to any flag.

pub fn empty() -> Self

Create an empty BitFlags. Empty means 0.

pub fn all() -> Self

Create a BitFlags with all flags set.

pub fn is_all(self) -> bool

Returns true if all flags are set

pub fn is_empty(self) -> bool

Returns true if no flag is set

pub fn bits(self) -> T::Type

Returns the underlying type value

pub fn intersects<B: Into<BitFlags<T>>>(self, other: B) -> bool

Returns true if at least one flag is shared.

pub fn contains<B: Into<BitFlags<T>>>(self, other: B) -> bool

Returns true if all flags are contained.

pub fn from_bits(bits: T::Type) -> Result<Self, FromBitsError<T>>

Returns a BitFlags<T> if the raw value provided does not contain any illegal flags.

pub fn from_flag(flag: T) -> Self

Turn a T into a BitFlags<T>. Also available as flag.into().

pub fn from_bits_truncate(bits: T::Type) -> Self

Truncates flags that are illegal

pub fn toggle<B: Into<BitFlags<T>>>(&mut self, other: B)

Toggles the matching bits

pub fn insert<B: Into<BitFlags<T>>>(&mut self, other: B)

Inserts the flags into the BitFlag

pub fn remove<B: Into<BitFlags<T>>>(&mut self, other: B)

Removes the matching flags

pub fn iter(self) -> impl Iterator<Item = T>

Returns an iterator that yields each set flag

Trait Implementations

impl<T> Binary for BitFlags<T> where
    T: RawBitFlags,
    T::Type: Binary, 

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

Formats the value using the given formatter.

impl<T, B> BitAnd<B> for BitFlags<T> where
    T: RawBitFlags,
    B: Into<BitFlags<T>>, 

type Output = BitFlags<T>

The resulting type after applying the & operator.

fn bitand(self, other: B) -> BitFlags<T>

Performs the & operation.

impl<T, B> BitAndAssign<B> for BitFlags<T> where
    T: RawBitFlags,
    B: Into<BitFlags<T>>, 

fn bitand_assign(&mut self, other: B)

Performs the &= operation.

impl<T, B> BitOr<B> for BitFlags<T> where
    T: RawBitFlags,
    B: Into<BitFlags<T>>, 

type Output = BitFlags<T>

The resulting type after applying the | operator.

fn bitor(self, other: B) -> BitFlags<T>

Performs the | operation.

impl<T, B> BitOrAssign<B> for BitFlags<T> where
    T: RawBitFlags,
    B: Into<BitFlags<T>>, 

fn bitor_assign(&mut self, other: B)

Performs the |= operation.

impl<T, B> BitXor<B> for BitFlags<T> where
    T: RawBitFlags,
    B: Into<BitFlags<T>>, 

type Output = BitFlags<T>

The resulting type after applying the ^ operator.

fn bitxor(self, other: B) -> BitFlags<T>

Performs the ^ operation.

impl<T, B> BitXorAssign<B> for BitFlags<T> where
    T: RawBitFlags,
    B: Into<BitFlags<T>>, 

fn bitxor_assign(&mut self, other: B)

Performs the ^= operation.

impl<T: Clone + RawBitFlags> Clone for BitFlags<T> where
    T::Type: Clone, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for BitFlags<T> where
    T: RawBitFlags + Debug, 

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

Formats the value using the given formatter.

impl<T> Default for BitFlags<T> where
    T: RawBitFlags, 

The default value returned is one with all flags unset, i. e. empty.

fn default() -> Self

Returns the “default value” for a type.

impl<T, B> Extend<B> for BitFlags<T> where
    T: RawBitFlags,
    B: Into<BitFlags<T>>, 

fn extend<I>(&mut self, it: I) where
    I: IntoIterator<Item = B>, 

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: RawBitFlags> From<T> for BitFlags<T>

fn from(t: T) -> BitFlags<T>

Performs the conversion.

impl<T, B> FromIterator<B> for BitFlags<T> where
    T: RawBitFlags,
    B: Into<BitFlags<T>>, 

fn from_iter<I>(it: I) -> BitFlags<T> where
    I: IntoIterator<Item = B>, 

Creates a value from an iterator.

impl<T: Hash + RawBitFlags> Hash for BitFlags<T> where
    T::Type: 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, 

Feeds a slice of this type into the given Hasher.

impl<T> LowerHex for BitFlags<T> where
    T: RawBitFlags,
    T::Type: LowerHex, 

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

Formats the value using the given formatter.

impl<T> Not for BitFlags<T> where
    T: RawBitFlags, 

type Output = BitFlags<T>

The resulting type after applying the ! operator.

fn not(self) -> BitFlags<T>

Performs the unary ! operation.

impl<T> Octal for BitFlags<T> where
    T: RawBitFlags,
    T::Type: Octal, 

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

Formats the value using the given formatter.

impl<T, B> PartialEq<B> for BitFlags<T> where
    T: RawBitFlags,
    B: Into<BitFlags<T>> + Copy, 

fn eq(&self, other: &B) -> 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 !=.

impl<T> TryFrom<u16> for BitFlags<T> where
    T: RawBitFlags<Type = u16>, 

type Error = FromBitsError<T>

The type returned in the event of a conversion error.

fn try_from(bits: T::Type) -> Result<Self, Self::Error>

Performs the conversion.

impl<T> TryFrom<u32> for BitFlags<T> where
    T: RawBitFlags<Type = u32>, 

type Error = FromBitsError<T>

The type returned in the event of a conversion error.

fn try_from(bits: T::Type) -> Result<Self, Self::Error>

Performs the conversion.

impl<T> TryFrom<u64> for BitFlags<T> where
    T: RawBitFlags<Type = u64>, 

type Error = FromBitsError<T>

The type returned in the event of a conversion error.

fn try_from(bits: T::Type) -> Result<Self, Self::Error>

Performs the conversion.

impl<T> TryFrom<u8> for BitFlags<T> where
    T: RawBitFlags<Type = u8>, 

type Error = FromBitsError<T>

The type returned in the event of a conversion error.

fn try_from(bits: T::Type) -> Result<Self, Self::Error>

Performs the conversion.

impl<T> TryFrom<usize> for BitFlags<T> where
    T: RawBitFlags<Type = usize>, 

type Error = FromBitsError<T>

The type returned in the event of a conversion error.

fn try_from(bits: T::Type) -> Result<Self, Self::Error>

Performs the conversion.

impl<T> UpperHex for BitFlags<T> where
    T: RawBitFlags,
    T::Type: UpperHex, 

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

Formats the value using the given formatter.

impl<T: Copy + RawBitFlags> Copy for BitFlags<T> where
    T::Type: Copy, 

impl<T: Eq + RawBitFlags> Eq for BitFlags<T> where
    T::Type: Eq, 

impl<T: RawBitFlags> StructuralEq for BitFlags<T>