[sync] Add constexpr to EnumSet

components/sync/base/enum_set.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef COMPONENTS_SYNC_BASE_ENUM_SET_H_
 #define COMPONENTS_SYNC_BASE_ENUM_SET_H_
 
 #include <bitset>
 #include <cstddef>
 #include <string>
@@ skipping 101 matching lines @@
       }
       return i;
     }
 
     const EnumBitSet* enums_;
     size_t i_;
   };
 
   EnumSet() {}
 
-  // Recursively chain constructors. Base case is the empty pack.
-  template <class... T>
-  EnumSet(E head, T... tail) : EnumSet(tail...) {
-    Put(head);
+  ~EnumSet() = default;
+
+  static constexpr uint64_t single_val_bitstring(E val) {
+    return 1ULL << (ToIndex(val));
   }
 
+  // Base case for recursive packing of a list of enum values. The uint64_t
+  // corresponding to an empty list is 0.
+  static constexpr uint64_t bitstring() { return 0ULL; }
+
+  // As of writing, constexpr expressions can't contain anything other than a
+  // return statement (and static asserts). To pack a variable number of enum
+  // value arguments into a bitstring, we use template varargs with a recursive
+  // constructor. Each recursive call packs one more enum into the bitstring,
+  // and the individual results are combined with bitwise or.
+  template <class... T>
+  static constexpr uint64_t bitstring(E head, T... tail) {
+    return (single_val_bitstring(head)) | bitstring(tail...);
+  }
+
+  template <class... T>
+  constexpr EnumSet(E head, T... tail)
+      : EnumSet(EnumBitSet(bitstring(head, tail...))) {}
+
   // Returns an EnumSet with all possible values.
-  static EnumSet All() {
-    EnumBitSet enums;
-    enums.set();
-    return EnumSet(enums);
+  static constexpr EnumSet All() {
+    return EnumSet(EnumBitSet((1ULL << kValueCount) - 1));
   }
 
   // Returns an EnumSet with all the values from start to end, inclusive.
-  static EnumSet FromRange(E start, E end) {
-    EnumSet set;
-    set.PutRange(start, end);
-    return set;
+  static constexpr EnumSet FromRange(E start, E end) {
+    return EnumSet(EnumBitSet(
+        ((single_val_bitstring(end)) - (single_val_bitstring(start))) |
+        (single_val_bitstring(end))));
   }
 
-  ~EnumSet() {}
-
   // Copy constructor and assignment welcome.
 
   // Set operations.  Put, Retain, and Remove are basically
   // self-mutating versions of Union, Intersection, and Difference
   // (defined below).
 
   // Adds the given value (which must be in range) to our set.
   void Put(E value) { enums_.set(ToIndex(value)); }
 
   // Adds all values in the given set to our set.
@@ skipping 21 matching lines @@
     }
   }
 
   // Removes all values in the given set from our set.
   void RemoveAll(EnumSet other) { enums_ &= ~other.enums_; }
 
   // Removes all values from our set.
   void Clear() { enums_.reset(); }
 
   // Returns true iff the given value is in range and a member of our set.
-  bool Has(E value) const {
-    return InRange(value) && enums_.test(ToIndex(value));
+  constexpr bool Has(E value) const {
+    return InRange(value) && enums_[ToIndex(value)];
   }
 
   // Returns true iff the given set is a subset of our set.
   bool HasAll(EnumSet other) const {
     return (enums_ & other.enums_) == other.enums_;
   }
 
   // Returns true iff our set is empty.
   bool Empty() const { return !enums_.any(); }
 
@@ skipping 11 matching lines @@
   bool operator!=(const EnumSet& other) const { return enums_ != other.enums_; }
 
  private:
   friend EnumSet Union<E, MinEnumValue, MaxEnumValue>(EnumSet set1,
                                                       EnumSet set2);
   friend EnumSet Intersection<E, MinEnumValue, MaxEnumValue>(EnumSet set1,
                                                              EnumSet set2);
   friend EnumSet Difference<E, MinEnumValue, MaxEnumValue>(EnumSet set1,
                                                            EnumSet set2);
 
-  explicit EnumSet(EnumBitSet enums) : enums_(enums) {}
+  // A bitset can't be constexpr constructed if it has size > 64, since the
+  // constexpr constructor uses a uint64_t. If your EnumSet has > 64 values, you
+  // can safely remove the constepxr qualifiers from this file, at the cost of
+  // some minor optimizations.
+  explicit constexpr EnumSet(EnumBitSet enums) : enums_(enums) {
+    static_assert(kValueCount < 64,
+                  "Max number of enum values is 64 for constexpr ");
+  }
 
-  static bool InRange(E value) {
+  static constexpr bool InRange(E value) {
     return (value >= MinEnumValue) && (value <= MaxEnumValue);
   }
 
   // Converts a value to/from an index into |enums_|.
 
-  static size_t ToIndex(E value) {
-    DCHECK_GE(value, MinEnumValue);
-    DCHECK_LE(value, MaxEnumValue);
-    return value - MinEnumValue;
-  }
+  static constexpr size_t ToIndex(E value) { return value - MinEnumValue; }
 
   static E FromIndex(size_t i) {
     DCHECK_LT(i, kValueCount);
     return static_cast<E>(MinEnumValue + i);
   }
 
   EnumBitSet enums_;
 };
 
 template <typename E, E MinEnumValue, E MaxEnumValue>
@@ skipping 21 matching lines @@
 
 template <typename E, E Min, E Max>
 EnumSet<E, Min, Max> Difference(EnumSet<E, Min, Max> set1,
                                 EnumSet<E, Min, Max> set2) {
   return EnumSet<E, Min, Max>(set1.enums_ & ~set2.enums_);
 }
 
 }  // namespace syncer
 
 #endif  // COMPONENTS_SYNC_BASE_ENUM_SET_H_