WTF: Support enums in DefaultHash and HashTraits by casting to integral types.

third_party/WebKit/Source/wtf/HashTraits.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights
  * reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 17 matching lines @@
 #include "wtf/StdLibExtras.h"
 #include "wtf/TypeTraits.h"
 #include <limits>
 #include <memory>
 #include <string.h>  // For memset.
 #include <type_traits>
 #include <utility>
 
 namespace WTF {
 
-template <bool isInteger, typename T>
+template <bool isInteger, bool isEnum, typename T>
 struct GenericHashTraitsBase;
 template <typename T>
 struct HashTraits;
 
 enum ShouldWeakPointersBeMarkedStrongly {
   WeakPointersActStrong,
   WeakPointersActWeak
 };
 
 template <typename T>
-struct GenericHashTraitsBase<false, T> {
+struct GenericHashTraitsBase<false, false, T> {
   // The emptyValueIsZero flag is used to optimize allocation of empty hash
   // tables with zeroed memory.
   static const bool emptyValueIsZero = false;
 
   // The hasIsEmptyValueFunction flag allows the hash table to automatically
   // generate code to check for the empty value when it can be done with the
   // equality operator, but allows custom functions for cases like String that
   // need them.
   static const bool hasIsEmptyValueFunction = false;
 
@@ skipping 21 matching lines @@
   template <typename U = void>
   struct NeedsToForbidGCOnMove {
     // TODO(yutak): Consider using of std:::is_trivially_move_constructible
     // when it is accessible.
     static const bool value = !std::is_pod<T>::value;
   };
 
   static const WeakHandlingFlag weakHandlingFlag =
       IsWeak<T>::value ? WeakHandlingInCollections
                        : NoWeakHandlingInCollections;
+
+  static T emptyValue() { return T(); }
 };
 
 // Default integer traits disallow both 0 and -1 as keys (max value instead of
 // -1 for unsigned).
 template <typename T>
-struct GenericHashTraitsBase<true, T> : GenericHashTraitsBase<false, T> {
+struct GenericHashTraitsBase<true, false, T>
+    : GenericHashTraitsBase<false, false, T> {
+  static_assert(std::is_integral<T>::value, "These traits are for integers");
   static const bool emptyValueIsZero = true;
   static void constructDeletedValue(T& slot, bool) {
     slot = static_cast<T>(-1);
   }
   static bool isDeletedValue(T value) { return value == static_cast<T>(-1); }
 };
 
+// Default enum traits disallow both -1 and -2 as keys (max and max-1 for
+// enums with unsigned underlying types).
 template <typename T>
-struct GenericHashTraits
-    : GenericHashTraitsBase<std::is_integral<T>::value, T> {
+struct GenericHashTraitsBase<false, true, T>
+    : GenericHashTraitsBase<false, false, T> {
+  static_assert(std::is_enum<T>::value, "These traits are for enums");
+  static T emptyValue() { return static_cast<T>(-1); }
+  static void constructDeletedValue(T& slot, bool) {
+    slot = static_cast<T>(-2);
+  }
+  static bool isDeletedValue(T value) { return value == static_cast<T>(-2); }
+};
+
+template <typename T>
+struct GenericHashTraits : GenericHashTraitsBase<std::is_integral<T>::value,
+                                                 std::is_enum<T>::value,
+                                                 T> {
   typedef T TraitType;
   typedef T EmptyValueType;
 
-  static T emptyValue() { return T(); }
-
   // Type for functions that do not take ownership, such as contains.
   typedef const T& PeekInType;
   typedef T* IteratorGetType;
   typedef const T* IteratorConstGetType;
   typedef T& IteratorReferenceType;
   typedef const T& IteratorConstReferenceType;
   static IteratorReferenceType getToReferenceConversion(IteratorGetType x) {
     return *x;
   }
   static IteratorConstReferenceType getToReferenceConstConversion(
@@ skipping 298 matching lines @@
 };
 
 }  // namespace WTF
 
 using WTF::HashTraits;
 using WTF::PairHashTraits;
 using WTF::NullableHashTraits;
 using WTF::SimpleClassHashTraits;
 
 #endif  // WTF_HashTraits_h