[sync] Purge directory data when migrating to USS

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 83 matching lines @@
     }
 
     // Moves the iterator to the next value in the EnumSet.  Good()
     // must hold.  Takes linear time.
     void Inc() {
       CHECK(Good());
       i_ = FindNext(i_ + 1);
     }
 
    private:
-    friend Iterator EnumSet::First() const;
+    friend constexpr Iterator EnumSet::First() const;
 
     explicit Iterator(const EnumBitSet& enums)
         : enums_(&enums), i_(FindNext(0)) {}
 
     size_t FindNext(size_t i) {
       while ((i < kValueCount) && !enums_->test(i)) {
         ++i;
       }
       return i;
     }
 
     const EnumBitSet* enums_;
     size_t i_;
   };
 
-  EnumSet() {}
+  EnumSet() = default;
+
+  ~EnumSet() = default;
 
   // Recursively chain constructors. Base case is the empty pack.
   template <class... T>
   EnumSet(E head, T... tail) : EnumSet(tail...) {
     Put(head);
   }
 
-  // Returns an EnumSet with all possible values.
-  static EnumSet All() {
-    EnumBitSet enums;
-    enums.set();
-    return EnumSet(enums);
+  // For a given list of enum values, calculates the equivalent 64 bit bitstring
+  // which is represented as a uint64_t.
+  constexpr uint64_t bitstring(
+      typename std::initializer_list<E>::const_iterator const& first,
+      typename std::initializer_list<E>::const_iterator const& last) const {
+    static_assert(
+        kValueCount < 64,
+        "Max number of enum values is 64 for constexpr initialization");
+    return first != last ? ((1ULL << unsigned(ToIndex(*first))) |
+                            bitstring(first + 1, last))
+                         : 0;
   }
 
+  constexpr EnumSet(const std::initializer_list<E>& enum_list)
+      : EnumSet(EnumBitSet(bitstring(begin(enum_list), end(enum_list)))) {}
+
+  // Returns an EnumSet with all possible values.
+  static constexpr EnumSet All() { return EnumSet((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) {
+    static_assert(
+        kValueCount < 64,
+        "Max number of enum values is 64 for constexpr initialization");
+    return EnumSet(
+        EnumBitSet(((1ULL << ToIndex(end)) - (1ULL << ToIndex(start))) |
+                   (1ULL << ToIndex(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(); }
 
   // Returns how many values our set has.
   size_t Size() const { return enums_.count(); }
 
   // Returns an iterator pointing to the first element (if any).
-  Iterator First() const { return Iterator(enums_); }
+  constexpr Iterator First() const { return Iterator(enums_); }
 
   // Returns true iff our set and the given set contain exactly the same values.
   bool operator==(const EnumSet& other) const { return enums_ == other.enums_; }
 
   // Returns true iff our set and the given set do not contain exactly the same
   // values.
   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) {}
+  explicit constexpr EnumSet(EnumBitSet enums) : enums_(enums) {}
 
-  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_