Struct BitFlags

pub struct BitFlags<T: RawBitFlags> { /* private fields */ }

Implementations

impl<T> BitFlags<T>

where T: RawBitFlags,

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

Create a new BitFlags unsafely. Consider using from_bits or from_bits_truncate.

impl<T> BitFlags<T>

where T: RawBitFlags,

pub fn empty() -> Self

Create an empty BitFlags. Empty means 0.

pub fn all() -> Self

Sets all flags.

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 iff all flags are contained.

pub fn not(self) -> Self

Flips all flags

pub fn from_bits(bits: T::Type) -> Option<Self>

Returns a BitFlags iff the bits value does not contain any illegal flags.

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

Trait Implementations

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 duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for BitFlags<T>

where T: RawBitFlags + BitFlagsFmt,

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

Formats the value using the given formatter.

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

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

Converts to this type from the input type.

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> 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, B> PartialEq<B> for BitFlags<T>

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

fn eq(&self, other: &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<T: Copy + RawBitFlags> Copy for BitFlags<T>

where T::Type: Copy,