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 {