Macro bitflags::bitflags

macro_rules! bitflags {
    (
        $(#[$outer:meta])*
        $vis:vis struct $BitFlags:ident: $T:ty {
            $(
                $(#[$inner:ident $($args:tt)*])*
                const $Flag:ident = $value:expr;
            )*
        }

        $($t:tt)*
    ) => { ... };
    (
        impl $BitFlags:ident: $T:ty {
            $(
                $(#[$inner:ident $($args:tt)*])*
                const $Flag:ident = $value:expr;
            )*
        }

        $($t:tt)*
    ) => { ... };
    () => { ... };
}

The macro used to generate the flag structure.

See the crate level docs for complete documentation.

Example

use bitflags::bitflags;

bitflags! {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
    struct Flags: u32 {
        const A = 0b00000001;
        const B = 0b00000010;
        const C = 0b00000100;
        const ABC = Self::A.bits() | Self::B.bits() | Self::C.bits();
    }
}

let e1 = Flags::A | Flags::C;
let e2 = Flags::B | Flags::C;
assert_eq!((e1 | e2), Flags::ABC);   // union
assert_eq!((e1 & e2), Flags::C);     // intersection
assert_eq!((e1 - e2), Flags::A);     // set difference
assert_eq!(!e2, Flags::A);           // set complement

The generated structs can also be extended with type and trait implementations:

use std::fmt;

use bitflags::bitflags;

bitflags! {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
    struct Flags: u32 {
        const A = 0b00000001;
        const B = 0b00000010;
    }
}

impl Flags {
    pub fn clear(&mut self) {
        *self.0.bits_mut() = 0;
    }
}

let mut flags = Flags::A | Flags::B;

flags.clear();
assert!(flags.is_empty());

assert_eq!(format!("{:?}", Flags::A | Flags::B), "Flags(A | B)");
assert_eq!(format!("{:?}", Flags::B), "Flags(B)");