Expanding Type Traits to make Vector use mem ops more.

Source/wtf/TypeTraits.h

  /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009, 2010 Google 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 11 matching lines @@
 #ifndef TypeTraits_h
 #define TypeTraits_h
 
 #include <utility>
 
 namespace WTF {
 
     // The following are provided in this file:
     //
     //   IsInteger<T>::value
-    //   IsPod<T>::value, see the definition for a note about its limitations
+    //   IsPod<T>::value
     //   IsConvertibleToInteger<T>::value
     //
     //   IsArray<T>::value
     //
     //   IsSameType<T, U>::value
     //
     //   RemovePointer<T>::Type
     //   RemoveReference<T>::Type
     //   RemoveConst<T>::Type
     //   RemoveVolatile<T>::Type
@@ skipping 22 matching lines @@
     template<> struct IsInteger<wchar_t>            { static const bool value = true; };
 #endif
 
     template<typename T> struct IsFloatingPoint     { static const bool value = false; };
     template<> struct IsFloatingPoint<float>        { static const bool value = true; };
     template<> struct IsFloatingPoint<double>       { static const bool value = true; };
     template<> struct IsFloatingPoint<long double>  { static const bool value = true; };
 
     template<typename T> struct IsArithmetic        { static const bool value = IsInteger<T>::value || IsFloatingPoint<T>::value; };
 
+    template<typename T> struct IsPointer {
+        static const bool value = false;
+    };
+
+    template<typename P> struct IsPointer<const P*> {
+        static const bool value = true;
+    };
+
+    template<typename P> struct IsPointer<P*> {
+        static const bool value = true;
+    };
+
+    template<typename T> struct IsEnum {
+        static const bool value = __is_enum(T);
+    };
+
+    template<typename T> struct IsScalar {
+        static const bool value = IsEnum<T>::value || IsArithmetic<T>::value || IsPointer<T>::value;
+    };
+
     template<typename T> struct IsWeak              { static const bool value = false; };
 
     enum WeakHandlingFlag {
         NoWeakHandlingInCollections,
         WeakHandlingInCollections
     };
 
-    // IsPod is misnamed as it doesn't cover all plain old data (pod) types.
-    // Specifically, it doesn't allow for enums or for structs.
-    template <typename T> struct IsPod              { static const bool value = IsArithmetic<T>::value; };
-    template <typename P> struct IsPod<P*>          { static const bool value = true; };
+    template <typename T> struct IsPod {
+        static const bool value = __is_pod(T);
+    };
+
+    template <typename T> struct IsTriviallyCopyAssignable {
+        static const bool value = __has_trivial_assign(T);
+    };
+
+    template <typename T> struct IsTriviallyMoveAssignable {
+        static const bool value = __has_trivial_assign(T);
+    };
+
+    template <typename T> struct IsTriviallyDefaultConstructible {
+        static const bool value = __has_trivial_constructor(T);
+    };
+
+    template <typename T> struct IsTriviallyDestructible {
+        static const bool value = __has_trivial_destructor(T);
+    };
 
     template<typename T> class IsConvertibleToInteger {
         // Avoid "possible loss of data" warning when using Microsoft's C++ compiler
         // by not converting int's to doubles.
         template<bool performCheck, typename U> class IsConvertibleToDouble;
         template<typename U> class IsConvertibleToDouble<false, U> {
         public:
             static const bool value = false;
         };
 
@@ skipping 241 matching lines @@
 };
 
 template<typename T, typename U>
 struct NeedsTracing<std::pair<T, U> > {
     static const bool value = NeedsTracing<T>::value || NeedsTracing<U>::value || IsWeak<T>::value || IsWeak<U>::value;
 };
 
 } // namespace WTF
 
 #endif // TypeTraits_h