A library for defining enums that can be used in compact bit sets. It supports enums up to 128 variants, and has a macro to use these sets in constants.

For serde support, enable the serde feature.

Defining enums for use with EnumSet

Enums to be used with [EnumSet] should be defined using #[derive(EnumSetType)]:

# use enumset::*;
#[derive(EnumSetType, Debug)]
pub enum Enum {
A, B, C, D, E, F, G,
}

Working with EnumSets

EnumSets can be constructed via [EnumSet::new()] like a normal set. In addition, #[derive(EnumSetType)] creates operator overloads that allow you to create EnumSets like so:

# use enumset::*;
# #[derive(EnumSetType, Debug)] pub enum Enum { A, B, C, D, E, F, G }
let new_set = Enum::A | Enum::C | Enum::G;
assert_eq!(new_set.len(), 3);

All bitwise operations you would expect to work on bitsets also work on both EnumSets and enums with #[derive(EnumSetType)]:

# use enumset::*;
# #[derive(EnumSetType, Debug)] pub enum Enum { A, B, C, D, E, F, G }
// Intersection of sets
assert_eq!((Enum::A | Enum::B) & Enum::C, EnumSet::empty());
assert_eq!((Enum::A | Enum::B) & Enum::A, Enum::A);
assert_eq!(Enum::A & Enum::B, EnumSet::empty());

// Symmetric difference of sets
assert_eq!((Enum::A | Enum::B) ^ (Enum::B | Enum::C), Enum::A | Enum::C);
assert_eq!(Enum::A ^ Enum::C, Enum::A | Enum::C);

// Difference of sets
assert_eq!((Enum::A | Enum::B | Enum::C) - Enum::B, Enum::A | Enum::C);

// Complement of sets
assert_eq!(!(Enum::E | Enum::G), Enum::A | Enum::B | Enum::C | Enum::D | Enum::F);

The [enum_set!] macro allows you to create EnumSets in constant contexts:

# use enumset::*;
# #[derive(EnumSetType, Debug)] pub enum Enum { A, B, C, D, E, F, G }
const CONST_SET: EnumSet<Enum> = enum_set!(Enum::A | Enum::B);
assert_eq!(CONST_SET, Enum::A | Enum::B);

Mutable operations on the [EnumSet] otherwise work basically as expected:

# use enumset::*;
# #[derive(EnumSetType, Debug)] pub enum Enum { A, B, C, D, E, F, G }
let mut set = EnumSet::new();
set.insert(Enum::A);
set.insert_all(Enum::E | Enum::G);
assert!(set.contains(Enum::A));
assert!(!set.contains(Enum::B));
assert_eq!(set, Enum::A | Enum::E | Enum::G);