mfbt/EnumSet.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 /* A set abstraction for enumeration values. */
   8
   9 #ifndef mozilla_EnumSet_h
  10 #define mozilla_EnumSet_h
  11
  12 #include "mozilla/Assertions.h"
  13 #include "mozilla/Attributes.h"
  14
  15 #include <initializer_list>
  16 #include <type_traits>
  17
  18 #include <stdint.h>
  19
  20 namespace mozilla {
  21
  22 /**
  23  * EnumSet<T, U> is a set of values defined by an enumeration. It is implemented
  24  * using a bit mask with the size of U for each value. It works both for enum
  25  * and enum class types.
  26  */
  27 template <typename T, typename Serialized = typename std::make_unsigned<
  28                           typename std::underlying_type<T>::type>::type>
  29 class EnumSet {
  30  public:
  31   typedef T valueType;
  32
  33   constexpr EnumSet() : mBitField(0) {}
  34
  35   constexpr MOZ_IMPLICIT EnumSet(T aEnum) : mBitField(bitFor(aEnum)) {}
  36
  37   constexpr EnumSet(T aEnum1, T aEnum2)
  38       : mBitField(bitFor(aEnum1) | bitFor(aEnum2)) {}
  39
  40   constexpr EnumSet(T aEnum1, T aEnum2, T aEnum3)
  41       : mBitField(bitFor(aEnum1) | bitFor(aEnum2) | bitFor(aEnum3)) {}
  42
  43   constexpr EnumSet(T aEnum1, T aEnum2, T aEnum3, T aEnum4)
  44       : mBitField(bitFor(aEnum1) | bitFor(aEnum2) | bitFor(aEnum3) |
  45                   bitFor(aEnum4)) {}
  46
  47   constexpr MOZ_IMPLICIT EnumSet(std::initializer_list<T> list) : mBitField(0) {
  48     for (auto value : list) {
  49       (*this) += value;
  50     }
  51   }
  52
  53 #ifdef DEBUG
  54   constexpr EnumSet(const EnumSet& aEnumSet) : mBitField(aEnumSet.mBitField) {}
  55
  56   constexpr EnumSet& operator=(const EnumSet& aEnumSet) {
  57     mBitField = aEnumSet.mBitField;
  58     incVersion();
  59     return *this;
  60   }
  61 #endif
  62
  63   /**
  64    * Add an element
  65    */
  66   constexpr void operator+=(T aEnum) {
  67     incVersion();
  68     mBitField |= bitFor(aEnum);
  69   }
  70
  71   /**
  72    * Add an element
  73    */
  74   constexpr EnumSet operator+(T aEnum) const {
  75     EnumSet result(*this);
  76     result += aEnum;
  77     return result;
  78   }
  79
  80   /**
  81    * Union
  82    */
  83   void operator+=(const EnumSet& aEnumSet) {
  84     incVersion();
  85     mBitField |= aEnumSet.mBitField;
  86   }
  87
  88   /**
  89    * Union
  90    */
  91   EnumSet operator+(const EnumSet& aEnumSet) const {
  92     EnumSet result(*this);
  93     result += aEnumSet;
  94     return result;
  95   }
  96
  97   /**
  98    * Remove an element
  99    */
 100   void operator-=(T aEnum) {
 101     incVersion();
 102     mBitField &= ~(bitFor(aEnum));
 103   }
 104
 105   /**
 106    * Remove an element
 107    */
 108   EnumSet operator-(T aEnum) const {
 109     EnumSet result(*this);
 110     result -= aEnum;
 111     return result;
 112   }
 113
 114   /**
 115    * Remove a set of elements
 116    */
 117   void operator-=(const EnumSet& aEnumSet) {
 118     incVersion();
 119     mBitField &= ~(aEnumSet.mBitField);
 120   }
 121
 122   /**
 123    * Remove a set of elements
 124    */
 125   EnumSet operator-(const EnumSet& aEnumSet) const {
 126     EnumSet result(*this);
 127     result -= aEnumSet;
 128     return result;
 129   }
 130
 131   /**
 132    * Clear
 133    */
 134   void clear() {
 135     incVersion();
 136     mBitField = 0;
 137   }
 138
 139   /**
 140    * Intersection
 141    */
 142   void operator&=(const EnumSet& aEnumSet) {
 143     incVersion();
 144     mBitField &= aEnumSet.mBitField;
 145   }
 146
 147   /**
 148    * Intersection
 149    */
 150   EnumSet operator&(const EnumSet& aEnumSet) const {
 151     EnumSet result(*this);
 152     result &= aEnumSet;
 153     return result;
 154   }
 155
 156   /**
 157    * Equality
 158    */
 159   bool operator==(const EnumSet& aEnumSet) const {
 160     return mBitField == aEnumSet.mBitField;
 161   }
 162
 163   /**
 164    * Equality
 165    */
 166   bool operator==(T aEnum) const { return mBitField == bitFor(aEnum); }
 167
 168   /**
 169    * Not equal
 170    */
 171   bool operator!=(const EnumSet& aEnumSet) const {
 172     return !operator==(aEnumSet);
 173   }
 174
 175   /**
 176    * Not equal
 177    */
 178   bool operator!=(T aEnum) const { return !operator==(aEnum); }
 179
 180   /**
 181    * Test is an element is contained in the set.
 182    */
 183   bool contains(T aEnum) const { return mBitField & bitFor(aEnum); }
 184
 185   /**
 186    * Test if a set is contained in the set.
 187    */
 188   bool contains(const EnumSet& aEnumSet) const {
 189     return (mBitField & aEnumSet.mBitField) == aEnumSet.mBitField;
 190   }
 191
 192   /**
 193    * Return the number of elements in the set.
 194    */
 195   uint8_t size() const {
 196     uint8_t count = 0;
 197     for (Serialized bitField = mBitField; bitField; bitField >>= 1) {
 198       if (bitField & 1) {
 199         count++;
 200       }
 201     }
 202     return count;
 203   }
 204
 205   bool isEmpty() const { return mBitField == 0; }
 206
 207   Serialized serialize() const { return mBitField; }
 208
 209   void deserialize(Serialized aValue) {
 210     incVersion();
 211     mBitField = aValue;
 212   }
 213
 214   class ConstIterator {
 215     const EnumSet* mSet;
 216     uint32_t mPos;
 217 #ifdef DEBUG
 218     uint64_t mVersion;
 219 #endif
 220
 221     void checkVersion() const {
 222       // Check that the set has not been modified while being iterated.
 223       MOZ_ASSERT_IF(mSet, mSet->mVersion == mVersion);
 224     }
 225
 226    public:
 227     ConstIterator(const EnumSet& aSet, uint32_t aPos)
 228         : mSet(&aSet), mPos(aPos) {
 229 #ifdef DEBUG
 230       mVersion = mSet->mVersion;
 231 #endif
 232       MOZ_ASSERT(aPos <= kMaxBits);
 233       if (aPos != kMaxBits && !mSet->contains(T(mPos))) ++*this;
 234     }
 235
 236     ConstIterator(const ConstIterator& aOther)
 237         : mSet(aOther.mSet), mPos(aOther.mPos) {
 238 #ifdef DEBUG
 239       mVersion = aOther.mVersion;
 240       checkVersion();
 241 #endif
 242     }
 243
 244     ConstIterator(ConstIterator&& aOther)
 245         : mSet(aOther.mSet), mPos(aOther.mPos) {
 246 #ifdef DEBUG
 247       mVersion = aOther.mVersion;
 248       checkVersion();
 249 #endif
 250       aOther.mSet = nullptr;
 251     }
 252
 253     ~ConstIterator() { checkVersion(); }
 254
 255     bool operator==(const ConstIterator& other) const {
 256       MOZ_ASSERT(mSet == other.mSet);
 257       checkVersion();
 258       return mPos == other.mPos;
 259     }
 260
 261     bool operator!=(const ConstIterator& other) const {
 262       return !(*this == other);
 263     }
 264
 265     T operator*() const {
 266       MOZ_ASSERT(mSet);
 267       MOZ_ASSERT(mPos < kMaxBits);
 268       MOZ_ASSERT(mSet->contains(T(mPos)));
 269       checkVersion();
 270       return T(mPos);
 271     }
 272
 273     ConstIterator& operator++() {
 274       MOZ_ASSERT(mSet);
 275       MOZ_ASSERT(mPos < kMaxBits);
 276       checkVersion();
 277       do {
 278         mPos++;
 279       } while (mPos < kMaxBits && !mSet->contains(T(mPos)));
 280       return *this;
 281     }
 282   };
 283
 284   ConstIterator begin() const { return ConstIterator(*this, 0); }
 285
 286   ConstIterator end() const { return ConstIterator(*this, kMaxBits); }
 287
 288  private:
 289   constexpr static Serialized bitFor(T aEnum) {
 290     auto bitNumber = static_cast<Serialized>(aEnum);
 291     MOZ_DIAGNOSTIC_ASSERT(bitNumber < kMaxBits);
 292     return static_cast<Serialized>(Serialized{1} << bitNumber);
 293   }
 294
 295   constexpr void incVersion() {
 296 #ifdef DEBUG
 297     mVersion++;
 298 #endif
 299   }
 300
 301   static const size_t kMaxBits = sizeof(Serialized) * 8;
 302
 303   Serialized mBitField;
 304
 305 #ifdef DEBUG
 306   uint64_t mVersion = 0;
 307 #endif
 308 };
 309
 310 }  // namespace mozilla
 311
 312 #endif /* mozilla_EnumSet_h_*/