## Background

Before writing this, I debated with myself whether to do a straight code dump or have a little set-up for any newbies who might come across this. Ultimately I decided to not exclude beginners. If you're not one of them, feel free to skip right to the next section.

With this out of the way... If you've programmed in C++ or C for a little while, you've probably had to deal with bitmasks. For example, the second parameter of the POSIX open function is a bitmask that lets you specify various options, such as whether to create the file if it doesn't already exist.

In short, you may think of a bitmask as an integer value where each bit specifies the state of a binary option. For example, the state of an old Nintendo controller could be represented with an 8-bit bitmask, where the first and second bits represent the state of the A and B buttons respectively (i.e. whether they are pressed down or not), the third and fourth bits - start and select, and the rest represent the directional buttons.

They typical way to implement this in C programs is by bitwise OR-ing together a bunch of powers of two. For example:

``````
#define BTN_A      0x01  /* 00000001 in binary */
#define BTN_B      0x02  /* 00000010 in binary */
#define BTN_SELECT 0x04  /* 00000100 */
#define BTN_START  0x08  /* 00001000 */
#define BTN_UP     0x10  /* 00010000 */
#define BTN_DOWN   0x20  /* 00100000 */
#define BTN_LEFT   0x40  /* 01000000 */
#define BTN_RIGHT  0x80  /* 10000000 */
```
```

If you wanted to encode the state of the controller that has both A and B buttons pressed, you'd write something like:

``````
uint8_t controller_state = BTN_A | BTN_B;
```
```
On the other hand, if you wanted to determine whether a given state has the "select" button pressed, you would use bitwise-AND to extract the value of the corresponding bit:
``````
if (controller_state & BTN_SELECT) {
// ...
}
```
```

The way of dealing with bitmasks described above is prone to a silly kind of bug - one may inadvertently OR or AND your bitmask with some value that isn't even intended to represent anything at all, and get odd behavior as a result. Admittedly, this is not something that happens every day, but if we could prevent it - why not? Plus, I get a kick out of catching potential bugs at compile time :)

Let's start by saying that we're going to represent possible options with enum values. For example:

``````
enum class Button {
A, B, Select, Start, Up, Down, Right, Left
};
```
```

Note that we don't explicitly set these to be powers of two - you'll see why in a moment.

We'll define the generic type `bitmask<T>` to represent bitmasks. It will work like this:

``````
enum class RamenToppings {
Egg,
Scallions,
Seaweed,
Mushrooms
};

// Thomas thinks ramen with no egg is a waste.
}

//...

printf(ThomasApproves(RamenToppings::Egg | RamenToppings::Scallions)
? "Thomas likes your choice of toppings!"
: "Thomas does not approve");
```
```

Now, let's dive into the implementation. It's not long at all, and I have added comments for those who might not be familiar with some newer C++ features.

``````
#include <type_traits>

template <class option_type,
// The line below ensures that bitmask can only be used with enums.
typename = typename std::enable_if<std::is_enum<option_type>::value>::type>
// The type we'll use for storing the value of our bitmask should be the same
// as the enum's underlying type.
using underlying_type = typename std::underlying_type<option_type>::type;

// This method helps us avoid having to explicitly set enum values to powers
// of two.
static constexpr underlying_type mask_value(option_type o) {
return 1 << static_cast<underlying_type>(o);
}

// Private ctor to be used internally.

public:
// Default ctor creates a bitmask with no options selected.

// Creates a bitmask with just one bit set.
// This ctor is intentionally non-explicit, to allow for stuff like:

// Set the bit corresponding to the given option.
}

// Get the value of the bit corresponding to the given option.
constexpr bool operator&(option_type t) {
}

private:
};

// Creates a bitmask from two options, convenient for stuff like:
// FunctionExpectingBitmask(Options::Opt1 | Options::Opt2 | Options::Opt3)
template <class option_type,
typename = typename std::enable_if<std::is_enum<option_type>::value>::type>
constexpr bitmask<option_type> operator|(option_type lhs, option_type rhs) {