Add support to the hashing infrastructure for automatically hashing both

[oota-llvm.git] / include / llvm / Support / type_traits.h

diff --git a/include/llvm/Support/type_traits.h b/include/llvm/Support/type_traits.h
index 85d90b17f17b5f4cc79ed67f561f1f5f7d3dbf72..a76344c098fe179fde5353f1aa03d0b44c7c7c95 100644 (file)
--- a/include/llvm/Support/type_traits.h
+++ b/include/llvm/Support/type_traits.h
@@ -121,12 +121,42 @@ template <> struct is_integral_impl<unsigned long long> : true_type {};
 template <typename T>
 struct is_integral : is_integral_impl<T> {};
 
+/// \brief Metafunction that determines whether the given type is either an
+/// integral type or an enumeration type.
+///
+/// Note that this accepts potentially more integral types than we whitelist
+/// above for is_integral, it should accept essentially anything the compiler
+/// believes is an integral type.
+template <typename T> class is_integral_or_enum {
+
+  // Form a return type that can only be instantiated with an integral or enum
+  // types (or with nullptr_t in C++11).
+  template <typename U, U u = U()> struct check1_return_type { char c[2]; };
+  template <typename U> static check1_return_type<U> checker1(U*);
+  static char checker1(...);
+
+  // Form a return type that can only be instantiated with nullptr_t in C++11
+  // mode. It's harmless in C++98 mode, but this allows us to filter nullptr_t
+  // when building in C++11 mode without having to detect that mode for each
+  // different compiler.
+  struct nonce {};
+  template <typename U, nonce* u = U()>
+  struct check2_return_type { char c[2]; };
+  template <typename U> static check2_return_type<U> checker2(U*);
+  static char checker2(...);
+
+public:
+  enum {
+    value = (sizeof(char) != sizeof(checker1((T*)0)) &&
+             sizeof(char) == sizeof(checker2((T*)0)))
+  };
+};
+
 /// \brief Metafunction that determines whether the given type is a pointer
 /// type.
 template <typename T> struct is_pointer : false_type {};
 template <typename T> struct is_pointer<T*> : true_type {};
 
-  
 // enable_if_c - Enable/disable a template based on a metafunction
 template<bool Cond, typename T = void>
 struct enable_if_c {