Crate enumflags2[−][src]

Enum Flags

enumflags2 defines a BitFlags<T> type, which is a Set<T> for enums without associated data.

Example

use enumflags2::BitFlags;

#[derive(BitFlags, Copy, Clone, Debug, PartialEq)]
#[repr(u8)]
enum Test {
    A = 0b0001,
    B = 0b0010,
    C = 0b0100,
    D = 0b1000,
}

let a_b = Test::A | Test::B; // BitFlags<Test>
let a_c = Test::A | Test::C;
let b_c_d = Test::C | Test::B | Test::D;

// BitFlags<Test>(0b11, [A, B])
println!("{:?}", a_b);

// BitFlags<Test>(0b1, [A])
println!("{:?}", a_b & a_c);

// Iterate over the flags like a normal set!
assert_eq!(a_b.iter().collect::<Vec<_>>(), &[Test::A, Test::B]);

assert!(a_b.contains(Test::A));
assert!(b_c_d.contains(Test::B | Test::C));
assert!(!(b_c_d.contains(a_b)));

assert!(a_b.intersects(a_c));
assert!(!(a_b.intersects(Test::C | Test::D)));

Note

By default, the BitFlags are usize-sized. If you want them to be smaller, specify a repr on your enum as in the example above.

Optional Feature Flags

serde implements Serialize and Deserialize for BitFlags<T>.
std implements std::error::Error for FromBitsError.
not_literal enables a workaround that allows using discriminant expressions that can’t be evaluated at macro expansion time. Notably, this includes using pre-existing constants.

This is disabled by default because of the high potential for confusing error messages - if a flag doesn’t have exactly one bit set, the error message will be “attempt to subtract with overflow”, pointing at the relevant flag.

The minimum rustc version has been bumped to 1.34.0, because of syn 1.0. The version policy from now on will be “what’s available on Debian stable”, because Debian is famously slow with new software versions.

You should no longer depend on enumflags2_derive directly. Use the reexport from the enumflags2 crate. semver guarantees will be violated if you depend on the derive crate directly.

The derive macro has been renamed to BitFlags, to make it clearer what the derive does.

The nostd feature flag has been removed. The crate now only depends on libcore by default. Enable the std flag to get an implementation of std::error::Error on error types.

Flags more than one bit set have been found to have inconsistent semantics. They are now rejected at compile-time. The same applies to flags without any bit set. If you were relying on this in your code, please open an issue and explain your usecase.

BitFlags::from_bits returns a Result instead of an Option. This might necessitate some minor changes in your code.

BitFlags::not has been removed. Use the ! operator instead.

Structs

BitFlags	Represents a set of flags of some type `T`. The type must have the `#[derive(BitFlags)]` attribute applied.
FromBitsError	The error struct used by `BitFlags::from_bits` and the `TryFrom` implementation` for invalid values.

Traits

RawBitFlags

A trait automatically implemented by derive(BitFlags) to make the enum a valid type parameter for BitFlags<T>.