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 <stdint.h>
  16
  17 namespace mozilla {
  18
  19 /**
  20  * EnumSet<T> is a set of values defined by an enumeration. It is implemented
  21  * using a 32 bit mask for each value so it will only work for enums with an int
  22  * representation less than 32. It works both for enum and enum class types.
  23  */
  24 template<typename T>
  25 class EnumSet
  26 {
  27 public:
  28   EnumSet()
  29     : mBitField(0)
  30   { }
  31
  32   MOZ_IMPLICIT EnumSet(T aEnum)
  33     : mBitField(bitFor(aEnum))
  34   { }
  35
  36   EnumSet(T aEnum1, T aEnum2)
  37     : mBitField(bitFor(aEnum1) |
  38                 bitFor(aEnum2))
  39   { }
  40
  41   EnumSet(T aEnum1, T aEnum2, T aEnum3)
  42     : mBitField(bitFor(aEnum1) |
  43                 bitFor(aEnum2) |
  44                 bitFor(aEnum3))
  45   { }
  46
  47   EnumSet(T aEnum1, T aEnum2, T aEnum3, T aEnum4)
  48    : mBitField(bitFor(aEnum1) |
  49                bitFor(aEnum2) |
  50                bitFor(aEnum3) |
  51                bitFor(aEnum4))
  52   { }
  53
  54   EnumSet(const EnumSet& aEnumSet)
  55    : mBitField(aEnumSet.mBitField)
  56   { }
  57
  58   /**
  59    * Add an element
  60    */
  61   void operator+=(T aEnum)
  62   {
  63     mBitField |= bitFor(aEnum);
  64   }
  65
  66   /**
  67    * Add an element
  68    */
  69   EnumSet<T> operator+(T aEnum) const
  70   {
  71     EnumSet<T> result(*this);
  72     result += aEnum;
  73     return result;
  74   }
  75
  76   /**
  77    * Union
  78    */
  79   void operator+=(const EnumSet<T> aEnumSet)
  80   {
  81     mBitField |= aEnumSet.mBitField;
  82   }
  83
  84   /**
  85    * Union
  86    */
  87   EnumSet<T> operator+(const EnumSet<T> aEnumSet) const
  88   {
  89     EnumSet<T> result(*this);
  90     result += aEnumSet;
  91     return result;
  92   }
  93
  94   /**
  95    * Remove an element
  96    */
  97   void operator-=(T aEnum)
  98   {
  99     mBitField &= ~(bitFor(aEnum));
 100   }
 101
 102   /**
 103    * Remove an element
 104    */
 105   EnumSet<T> operator-(T aEnum) const
 106   {
 107     EnumSet<T> result(*this);
 108     result -= aEnum;
 109     return result;
 110   }
 111
 112   /**
 113    * Remove a set of elements
 114    */
 115   void operator-=(const EnumSet<T> aEnumSet)
 116   {
 117     mBitField &= ~(aEnumSet.mBitField);
 118   }
 119
 120   /**
 121    * Remove a set of elements
 122    */
 123   EnumSet<T> operator-(const EnumSet<T> aEnumSet) const
 124   {
 125     EnumSet<T> result(*this);
 126     result -= aEnumSet;
 127     return result;
 128   }
 129
 130   /**
 131    * Intersection
 132    */
 133   void operator&=(const EnumSet<T> aEnumSet)
 134   {
 135     mBitField &= aEnumSet.mBitField;
 136   }
 137
 138   /**
 139    * Intersection
 140    */
 141   EnumSet<T> operator&(const EnumSet<T> aEnumSet) const
 142   {
 143     EnumSet<T> result(*this);
 144     result &= aEnumSet;
 145     return result;
 146   }
 147
 148   /**
 149    * Equality
 150    */
 151   bool operator==(const EnumSet<T> aEnumSet) const
 152   {
 153     return mBitField == aEnumSet.mBitField;
 154   }
 155
 156   /**
 157    * Test is an element is contained in the set.
 158    */
 159   bool contains(T aEnum) const
 160   {
 161     return mBitField & bitFor(aEnum);
 162   }
 163
 164   /**
 165    * Return the number of elements in the set.
 166    */
 167   uint8_t size()
 168   {
 169     uint8_t count = 0;
 170     for (uint32_t bitField = mBitField; bitField; bitField >>= 1) {
 171       if (bitField & 1) {
 172         count++;
 173       }
 174     }
 175     return count;
 176   }
 177
 178   bool isEmpty() const
 179   {
 180     return mBitField == 0;
 181   }
 182
 183   uint32_t serialize() const
 184   {
 185     return mBitField;
 186   }
 187
 188   void deserialize(uint32_t aValue)
 189   {
 190     mBitField = aValue;
 191   }
 192
 193 private:
 194   static uint32_t bitFor(T aEnum)
 195   {
 196     uint32_t bitNumber = (uint32_t)aEnum;
 197     MOZ_ASSERT(bitNumber < 32);
 198     return 1U << bitNumber;
 199   }
 200
 201   uint32_t mBitField;
 202 };
 203
 204 } // namespace mozilla
 205
 206 #endif /* mozilla_EnumSet_h_*/