Struct sawp_gre::Flags

#[repr(transparent)]
pub struct Flags<Enum, Primitive = <Enum as Flag>::Primitive> { /* private fields */ }

Storage type for handling flags

Implementations

impl<Enum> Flags<Enum, <Enum as Flag>::Primitive> where
    Enum: Flag, 

pub fn from_flag(flag: Enum) -> Flags<Enum, <Enum as Flag>::Primitive>

Get a flag from a single enum value

pub fn from_bits(
    bits: <Enum as Flag>::Primitive
) -> Flags<Enum, <Enum as Flag>::Primitive>

Get a flag from a numeric value

Note: the value is unchecked so any bit may be set. Be careful because PartialEq is a direct comparison of underlying bits.

pub fn bits(&self) -> <Enum as Flag>::Primitive

Numeric representation of the variant

pub fn bits_ref(&self) -> &<Enum as Flag>::Primitive

Reference to numeric representation of the variant

pub fn intersects<B>(self, rhs: B) -> bool where
    B: Into<Flags<Enum, <Enum as Flag>::Primitive>>, 

Check if at least one flag in common is set

pub fn contains<B>(self, rhs: B) -> bool where
    B: Into<Flags<Enum, <Enum as Flag>::Primitive>>, 

Check if all flags provided in rhs are set

pub fn is_empty(&self) -> bool

pub fn is_all(&self) -> bool

Trait Implementations

impl<T> Binary for Flags<T, <T as Flag>::Primitive> where
    T: Flag, 

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

Formats the value using the given formatter.

impl<T, B> BitAnd<B> for Flags<T, <T as Flag>::Primitive> where
    T: Flag,
    B: Into<Flags<T, <T as Flag>::Primitive>>, 

type Output = Flags<T, <T as Flag>::Primitive>

The resulting type after applying the & operator.

fn bitand(self, other: B) -> Flags<T, <T as Flag>::Primitive>

Performs the & operation.

impl<T, B> BitAndAssign<B> for Flags<T, <T as Flag>::Primitive> where
    T: Flag,
    B: Into<Flags<T, <T as Flag>::Primitive>>, 

fn bitand_assign(&mut self, rhs: B)

Performs the &= operation.

impl<T, B> BitOr<B> for Flags<T, <T as Flag>::Primitive> where
    T: Flag,
    B: Into<Flags<T, <T as Flag>::Primitive>>, 

type Output = Flags<T, <T as Flag>::Primitive>

The resulting type after applying the | operator.

fn bitor(self, other: B) -> Flags<T, <T as Flag>::Primitive>

Performs the | operation.

impl<T, B> BitOrAssign<B> for Flags<T, <T as Flag>::Primitive> where
    T: Flag,
    B: Into<Flags<T, <T as Flag>::Primitive>>, 

fn bitor_assign(&mut self, rhs: B)

Performs the |= operation.

impl<T, B> BitXor<B> for Flags<T, <T as Flag>::Primitive> where
    T: Flag,
    B: Into<Flags<T, <T as Flag>::Primitive>>, 

type Output = Flags<T, <T as Flag>::Primitive>

The resulting type after applying the ^ operator.

fn bitxor(self, other: B) -> Flags<T, <T as Flag>::Primitive>

Performs the ^ operation.

impl<T, B> BitXorAssign<B> for Flags<T, <T as Flag>::Primitive> where
    T: Flag,
    B: Into<Flags<T, <T as Flag>::Primitive>>, 

fn bitxor_assign(&mut self, rhs: B)

Performs the ^= operation.

impl<Enum, Primitive> Clone for Flags<Enum, Primitive> where
    Enum: Clone,
    Primitive: Clone, 

fn clone(&self) -> Flags<Enum, Primitive>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Enum> Debug for Flags<Enum, <Enum as Flag>::Primitive> where
    Enum: Flag, 

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

Formats the value using the given formatter.

impl<Enum> Default for Flags<Enum, <Enum as Flag>::Primitive> where
    Enum: Flag, 

fn default() -> Flags<Enum, <Enum as Flag>::Primitive>

Returns the “default value” for a type.

impl<T> Display for Flags<T, <T as Flag>::Primitive> where
    T: Flag, 

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

A pipe-separated list of set flags.

impl<Enum> From<Enum> for Flags<Enum, <Enum as Flag>::Primitive> where
    Enum: Flag, 

fn from(flag: Enum) -> Flags<Enum, <Enum as Flag>::Primitive>

Converts to this type from the input type.

impl<T> Not for Flags<T, <T as Flag>::Primitive> where
    T: Flag, 

type Output = Flags<T, <T as Flag>::Primitive>

The resulting type after applying the ! operator.

fn not(self) -> <Flags<T, <T as Flag>::Primitive> as Not>::Output

Performs the unary ! operation.

impl<Enum> PartialEq<Enum> for Flags<Enum, <Enum as Flag>::Primitive> where
    Enum: Flag, 

fn eq(&self, other: &Enum) -> 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<Enum, Primitive> PartialEq<Flags<Enum, Primitive>> for Flags<Enum, Primitive> where
    Enum: PartialEq<Enum>,
    Primitive: PartialEq<Primitive>, 

fn eq(&self, other: &Flags<Enum, Primitive>) -> bool

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

fn ne(&self, other: &Flags<Enum, Primitive>) -> bool

This method tests for !=.

impl PartialEq<Flags<ErrorFlags, <ErrorFlags as Flag>::Primitive>> for ErrorFlags

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

impl PartialEq<Flags<GreFlags, <GreFlags as Flag>::Primitive>> for GreFlags

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

impl<Enum, Primitive> Copy for Flags<Enum, Primitive> where
    Enum: Copy,
    Primitive: Copy, 

impl<Enum, Primitive> Eq for Flags<Enum, Primitive> where
    Enum: Eq,
    Primitive: Eq, 

impl<Enum, Primitive> StructuralEq for Flags<Enum, Primitive>

impl<Enum, Primitive> StructuralPartialEq for Flags<Enum, Primitive>