Trait Flags 

pub trait Flags<T: Into<Self>>:
    Copy
    + Clone
    + Debug
    + Send
    + Sync
    + 'static
    + PartialEq
    + Eq
    + BitAnd
    + BitOr
    + BitXor
    + BitAndAssign
    + BitOrAssign
    + BitXorAssign
    + Not
where
    <Self as BitAnd>::Output: PartialEq<Self> + Eq + Into<Self>,
    <Self as BitOr>::Output: PartialEq<Self> + Eq + Into<Self>,
    <Self as BitXor>::Output: PartialEq<Self> + Eq + Into<Self>,
    <Self as Not>::Output: Into<Self>,
{
    // Provided methods
    fn has_flag(&self, flag: T) -> bool { ... }
    fn set_flag(&mut self, flag: T) { ... }
    fn unset_flag(&mut self, flag: T) { ... }
}

Implemented on types that are capable of bitwise twiddling as a way of turning on and off different bit-specific flags, such as u8, u16, u32, u64, etc.

To integrate with Flags, custom enum types should implent From<T> where T is the type that implements Flags. You can then call has_flag, set_flag, and unset_flag on T using flags defined by the custom enum type, like so:

 use bit_flags::Flags;

 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 enum MyFlags {
     Flag1 = 1 << 0, // 0b00000001
     Flag2 = 1 << 1, // 0b00000010
     Flag3 = 1 << 2, // 0b00000100
     Flag4 = 1 << 3, // 0b00001000
 }

 impl From<MyFlags> for u8 {
     fn from(flag: MyFlags) -> Self {
         flag as u8
     }
 }

 let mut flags: u8 = MyFlags::Flag1 as u8 | MyFlags::Flag2 as u8;
 assert!(flags.has_flag(MyFlags::Flag1));
 assert!(flags.has_flag(MyFlags::Flag2));
 assert!(!flags.has_flag(MyFlags::Flag3));
 flags.set_flag(MyFlags::Flag3);
 assert!(flags.has_flag(MyFlags::Flag3));
 flags.set_flag(MyFlags::Flag1);
 assert!(flags.has_flag(MyFlags::Flag1));
 flags.unset_flag(MyFlags::Flag2);
 assert!(!flags.has_flag(MyFlags::Flag2));

 // You can also use the flags directly with bitwise operations:
 flags |= MyFlags::Flag4 as u8; // Set Flag4
 flags &= !(MyFlags::Flag1 as u8); // Unset Flag1
 assert!(flags.has_flag(MyFlags::Flag4));
 assert!(!flags.has_flag(MyFlags::Flag1));
 assert!(flags.has_flag(MyFlags::Flag3));
 assert!(!flags.has_flag(MyFlags::Flag2));

You can also use multi-byte flags:

 use bit_flags::Flags;

#[repr(u16)]
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 enum MyFlags {
     Flag1 = 1 << 0,   // 0b0000000000000001
     Flag2 = 1 << 1,   // 0b0000000000000010
     Flag3 = 1 << 2,   // 0b0000000000000100
     Flag4 = 1 << 3,   // 0b0000000000001000
     Flag5 = 1 << 4,   // 0b0000000000010000
     Flag6 = 1 << 5,   // 0b0000000000100000
     Flag7 = 1 << 6,   // 0b0000000001000000
     Flag8 = 1 << 7,   // 0b0000000010000000
     Flag9 = 1 << 8,   // 0b0000000100000000
     Flag10 = 1 << 9,  // 0b0000001000000000
     Flag11 = 1 << 10, // 0b0000010000000000
     Flag12 = 1 << 11, // 0b0000100000000000
     Flag13 = 1 << 12, // 0b0001000000000000
     Flag14 = 1 << 13, // 0b0010000000000000
     Flag15 = 1 << 14, // 0b0100000000000000
     Flag16 = 1 << 15, // 0b1000000000000000
 }

 impl From<MyFlags> for u16 {
    fn from(flag: MyFlags) -> Self {
        flag as u16
    }
 }

 let mut flags: u16 = MyFlags::Flag1 as u16 | MyFlags::Flag2 as u16;
 assert!(flags.has_flag(MyFlags::Flag1));
 assert!(flags.has_flag(MyFlags::Flag2));
 assert!(!flags.has_flag(MyFlags::Flag3));

 flags.set_flag(MyFlags::Flag15);
 assert!(flags.has_flag(MyFlags::Flag15));
 flags.unset_flag(MyFlags::Flag1);
 assert!(!flags.has_flag(MyFlags::Flag1));
 assert_eq!(flags, MyFlags::Flag2 as u16 | MyFlags::Flag15 as u16);

Provided Methods

fn has_flag(&self, flag: T) -> bool

fn set_flag(&mut self, flag: T)

Sets the specified flag on this flag set.

fn unset_flag(&mut self, flag: T)

Unsets the specified flag on this flag set.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<T, U> Flags<T> for U

where U: Copy + Clone + Debug + Send + Sync + 'static + PartialEq + Eq + BitAnd<Output = U> + BitOr<Output = U> + BitXor<Output = U> + BitAndAssign + BitOrAssign + BitXorAssign + Not<Output = U> + From<T>, T: Into<U> + Copy,