mfbt/EnumSet.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 /* A set abstraction for enumeration values. */
   7
   8 #ifndef mozilla_EnumSet_h
   9 #define mozilla_EnumSet_h
  10
  11 #include "mozilla/Assertions.h"
  12 #include "mozilla/StandardInteger.h"
  13
  14 namespace mozilla {
  15
  16 /**
  17  * EnumSet<T> is a set of values defined by an enumeration. It is implemented
  18  * using a 32 bit mask for each value so it will only work for enums with an int
  19  * representation less than 32. It works both for enum and enum class types.
  20  */
  21 template<typename T>
  22 class EnumSet
  23 {
  24   public:
  25     EnumSet()
  26       : mBitField(0)
  27     { }
  28
  29     EnumSet(T aEnum)
  30       : mBitField(aEnum)
  31     { }
  32
  33     EnumSet(T aEnum1, T aEnum2)
  34       : mBitField(bitFor(aEnum1) |
  35                   bitFor(aEnum2))
  36     { }
  37
  38     EnumSet(T aEnum1, T aEnum2, T aEnum3)
  39       : mBitField(bitFor(aEnum1) |
  40                   bitFor(aEnum2) |
  41                   bitFor(aEnum3))
  42     { }
  43
  44     EnumSet(T aEnum1, T aEnum2, T aEnum3, T aEnum4)
  45      : mBitField(bitFor(aEnum1) |
  46                  bitFor(aEnum2) |
  47                  bitFor(aEnum3) |
  48                  bitFor(aEnum4))
  49     { }
  50
  51     EnumSet(const EnumSet& aEnumSet)
  52      : mBitField(aEnumSet.mBitField)
  53     { }
  54
  55     /**
  56      * Add an element
  57      */
  58     void operator+=(T aEnum) {
  59       mBitField |= bitFor(aEnum);
  60     }
  61
  62     /**
  63      * Add an element
  64      */
  65     EnumSet<T> operator+(T aEnum) const {
  66       EnumSet<T> result(*this);
  67       result += aEnum;
  68       return result;
  69     }
  70
  71     /**
  72      * Union
  73      */
  74     void operator+=(const EnumSet<T> aEnumSet) {
  75       mBitField |= aEnumSet.mBitField;
  76     }
  77
  78     /**
  79      * Union
  80      */
  81     EnumSet<T> operator+(const EnumSet<T> aEnumSet) const {
  82       EnumSet<T> result(*this);
  83       result += aEnumSet;
  84       return result;
  85     }
  86
  87     /**
  88      * Remove an element
  89      */
  90     void operator-=(T aEnum) {
  91       mBitField &= ~(bitFor(aEnum));
  92     }
  93
  94     /**
  95      * Remove an element
  96      */
  97     EnumSet<T> operator-(T aEnum) const {
  98       EnumSet<T> result(*this);
  99       result -= aEnum;
 100       return result;
 101     }
 102
 103     /**
 104      * Remove a set of elements
 105      */
 106     void operator-=(const EnumSet<T> aEnumSet) {
 107       mBitField &= ~(aEnumSet.mBitField);
 108     }
 109
 110     /**
 111      * Remove a set of elements
 112      */
 113     EnumSet<T> operator-(const EnumSet<T> aEnumSet) const {
 114       EnumSet<T> result(*this);
 115       result -= aEnumSet;
 116       return result;
 117     }
 118
 119     /**
 120      * Intersection
 121      */
 122     void operator&=(const EnumSet<T> aEnumSet) {
 123       mBitField &= aEnumSet.mBitField;
 124     }
 125
 126     /**
 127      * Intersection
 128      */
 129     EnumSet<T> operator&(const EnumSet<T> aEnumSet) const {
 130       EnumSet<T> result(*this);
 131       result &= aEnumSet;
 132       return result;
 133     }
 134
 135     /**
 136      * Equality
 137      */
 138
 139     bool operator==(const EnumSet<T> aEnumSet) const {
 140       return mBitField == aEnumSet.mBitField;
 141     }
 142
 143     /**
 144      * Test is an element is contained in the set
 145      */
 146     bool contains(T aEnum) const {
 147       return mBitField & bitFor(aEnum);
 148     }
 149
 150     /**
 151      * Return the number of elements in the set
 152      */
 153
 154     uint8_t size() {
 155       uint8_t count = 0;
 156       for (uint32_t bitField = mBitField; bitField; bitField >>= 1) {
 157         if (bitField & 1)
 158           count++;
 159       }
 160       return count;
 161     }
 162
 163   private:
 164     static uint32_t bitFor(T aEnum) {
 165       uint32_t bitNumber(aEnum);
 166       MOZ_ASSERT(bitNumber < 32);
 167       return 1U << bitNumber;
 168     }
 169
 170     uint32_t mBitField;
 171 };
 172
 173 } // namespace mozilla
 174
 175 #endif // mozilla_EnumSet_h_