Struct LlamaTokenAttrs

Source

pub struct LlamaTokenAttrs(pub BitFlags<LlamaTokenAttr>);

Expand description

A set of LlamaTokenAttrs

Tuple Fields§

§0: BitFlags<LlamaTokenAttr>

Methods from Deref<Target = BitFlags<LlamaTokenAttr>>§

Source

pub fn iter(self) -> Iter<T> ⓘ

Iterate over the BitFlags.

let flags = make_bitflags!(MyFlag::{A | C});

flags.iter()
    .for_each(|flag| println!("{:?}", flag));

Source

pub fn union_c(self, other: BitFlags<T, u8>) -> BitFlags<T, u8>

Bitwise OR — return value contains flag if either argument does.

Also available as a | b, but operator overloads are not usable in const fns at the moment.

Source

pub fn intersection_c(self, other: BitFlags<T, u8>) -> BitFlags<T, u8>

Bitwise AND — return value contains flag if both arguments do.

Also available as a & b, but operator overloads are not usable in const fns at the moment.

Source

pub fn not_c(self, const_token: ConstToken<T, u8>) -> BitFlags<T, u8>

Bitwise NOT — return value contains flag if argument doesn’t.

Also available as !a, but operator overloads are not usable in const fns at the moment.

Moreover, due to const fn limitations, not_c needs a ConstToken as an argument.

#[bitflags]
#[repr(u8)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum MyFlag {
    One = 1 << 0,
    Two = 1 << 1,
    Three = 1 << 2,
}

const FLAGS: BitFlags<MyFlag> = make_bitflags!(MyFlag::{One | Two});
const NEGATED: BitFlags<MyFlag> = FLAGS.not_c(BitFlags::CONST_TOKEN);
assert_eq!(NEGATED, MyFlag::Three);

Source

pub fn bits_c(self) -> u8

Returns the underlying bitwise value.

const variant of bits.

Source

pub fn is_all(self) -> bool

Returns true if all flags are set

Source

pub fn is_empty(self) -> bool

Returns true if no flag is set

Source

pub fn len(self) -> usize

Returns the number of flags set.

Source

pub fn exactly_one(self) -> Option<T>

If exactly one flag is set, the flag is returned. Otherwise, returns None.

pub fn bits(self) -> <T as RawBitFlags>::Numeric

Returns the underlying bitwise value.

#[bitflags]
#[repr(u8)]
#[derive(Clone, Copy)]
enum Flags {
    Foo = 1 << 0,
    Bar = 1 << 1,
}

let both_flags = Flags::Foo | Flags::Bar;
assert_eq!(both_flags.bits(), 0b11);

Source

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

Returns true if at least one flag is shared.

Source

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

Returns true if all flags are contained.

Source

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

Toggles the matching bits

Source

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

Inserts the flags into the BitFlag

Source

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

Removes the matching flags

Source

pub fn set(&mut self, other: B, cond: bool)
where B: Into<BitFlags<T>>,

Inserts if cond holds, else removes

#[bitflags]
#[derive(Clone, Copy, PartialEq, Debug)]
#[repr(u8)]
enum MyFlag {
    A = 1 << 0,
    B = 1 << 1,
    C = 1 << 2,
}

let mut state = MyFlag::A | MyFlag::C;
state.set(MyFlag::A | MyFlag::B, false);

// Because the condition was false, both
// `A` and `B` are removed from the set
assert_eq!(state, MyFlag::C);