src/third_party/cld/base/type_traits.h

   1 // Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // This code is compiled directly on many platforms, including client
   6 // platforms like Windows, Mac, and embedded systems.  Before making
   7 // any changes here, make sure that you're not breaking any platforms.
   8 //
   9 //
  10 // Define a small subset of tr1 type traits. The traits we define are:
  11 //   is_integral
  12 //   is_floating_point
  13 //   is_pointer
  14 //   is_reference
  15 //   is_pod
  16 //   has_trivial_constructor
  17 //   has_trivial_copy
  18 //   has_trivial_assign
  19 //   has_trivial_destructor
  20 //   remove_const
  21 //   remove_volatile
  22 //   remove_cv
  23 //   remove_reference
  24 //   remove_pointer
  25 //   is_convertible
  26 // We can add more type traits as required.
  27
  28 #ifndef BASE_TYPE_TRAITS_H_
  29 #define BASE_TYPE_TRAITS_H_
  30
  31 #include "base/template_util.h"     // For true_type and false_type
  32 #include <utility>                  // For pair
  33
  34 namespace base {
  35
  36 // is_integral is false except for the built-in integer types.
  37 template <class T> struct is_integral : false_type { };
  38 template<> struct is_integral<bool> : true_type { };
  39 template<> struct is_integral<char> : true_type { };
  40 template<> struct is_integral<unsigned char> : true_type { };
  41 template<> struct is_integral<signed char> : true_type { };
  42 #if defined(_MSC_VER)
  43 // wchar_t is not by default a distinct type from unsigned short in
  44 // Microsoft C.
  45 // See http://msdn2.microsoft.com/en-us/library/dh8che7s(VS.80).aspx
  46 template<> struct is_integral<__wchar_t> : true_type { };
  47 #else
  48 template<> struct is_integral<wchar_t> : true_type { };
  49 #endif
  50 template<> struct is_integral<short> : true_type { };
  51 template<> struct is_integral<unsigned short> : true_type { };
  52 template<> struct is_integral<int> : true_type { };
  53 template<> struct is_integral<unsigned int> : true_type { };
  54 template<> struct is_integral<long> : true_type { };
  55 template<> struct is_integral<unsigned long> : true_type { };
  56 template<> struct is_integral<long long> : true_type { };
  57 template<> struct is_integral<unsigned long long> : true_type { };
  58
  59
  60 // is_floating_point is false except for the built-in floating-point types.
  61 template <class T> struct is_floating_point : false_type { };
  62 template<> struct is_floating_point<float> : true_type { };
  63 template<> struct is_floating_point<double> : true_type { };
  64 template<> struct is_floating_point<long double> : true_type { };
  65
  66
  67 // is_pointer is false except for pointer types.
  68 template <class T> struct is_pointer : false_type { };
  69 template <class T> struct is_pointer<T*> : true_type { };
  70
  71
  72 // is_reference is false except for reference types.
  73 template<typename T> struct is_reference : false_type {};
  74 template<typename T> struct is_reference<T&> : true_type {};
  75
  76
  77 // We can't get is_pod right without compiler help, so fail conservatively.
  78 // We will assume it's false except for arithmetic types and pointers,
  79 // and const versions thereof. Note that std::pair is not a POD.
  80 template <class T> struct is_pod
  81  : integral_constant<bool, (is_integral<T>::value ||
  82                             is_floating_point<T>::value ||
  83                             is_pointer<T>::value)> { };
  84 template <class T> struct is_pod<const T> : is_pod<T> { };
  85
  86
  87 // We can't get has_trivial_constructor right without compiler help, so
  88 // fail conservatively. We will assume it's false except for: (1) types
  89 // for which is_pod is true. (2) std::pair of types with trivial
  90 // constructors. (3) array of a type with a trivial constructor.
  91 // (4) const versions thereof.
  92 template <class T> struct has_trivial_constructor : is_pod<T> { };
  93 template <class T, class U> struct has_trivial_constructor<std::pair<T, U> >
  94   : integral_constant<bool,
  95                       (has_trivial_constructor<T>::value &&
  96                        has_trivial_constructor<U>::value)> { };
  97 template <class A, int N> struct has_trivial_constructor<A[N]>
  98   : has_trivial_constructor<A> { };
  99 template <class T> struct has_trivial_constructor<const T>
 100   : has_trivial_constructor<T> { };
 101
 102 // We can't get has_trivial_copy right without compiler help, so fail
 103 // conservatively. We will assume it's false except for: (1) types
 104 // for which is_pod is true. (2) std::pair of types with trivial copy
 105 // constructors. (3) array of a type with a trivial copy constructor.
 106 // (4) const versions thereof.
 107 template <class T> struct has_trivial_copy : is_pod<T> { };
 108 template <class T, class U> struct has_trivial_copy<std::pair<T, U> >
 109   : integral_constant<bool,
 110                       (has_trivial_copy<T>::value &&
 111                        has_trivial_copy<U>::value)> { };
 112 template <class A, int N> struct has_trivial_copy<A[N]>
 113   : has_trivial_copy<A> { };
 114 template <class T> struct has_trivial_copy<const T> : has_trivial_copy<T> { };
 115
 116 // We can't get has_trivial_assign right without compiler help, so fail
 117 // conservatively. We will assume it's false except for: (1) types
 118 // for which is_pod is true. (2) std::pair of types with trivial copy
 119 // constructors. (3) array of a type with a trivial assign constructor.
 120 template <class T> struct has_trivial_assign : is_pod<T> { };
 121 template <class T, class U> struct has_trivial_assign<std::pair<T, U> >
 122   : integral_constant<bool,
 123                       (has_trivial_assign<T>::value &&
 124                        has_trivial_assign<U>::value)> { };
 125 template <class A, int N> struct has_trivial_assign<A[N]>
 126   : has_trivial_assign<A> { };
 127
 128 // We can't get has_trivial_destructor right without compiler help, so
 129 // fail conservatively. We will assume it's false except for: (1) types
 130 // for which is_pod is true. (2) std::pair of types with trivial
 131 // destructors. (3) array of a type with a trivial destructor.
 132 // (4) const versions thereof.
 133 template <class T> struct has_trivial_destructor : is_pod<T> { };
 134 template <class T, class U> struct has_trivial_destructor<std::pair<T, U> >
 135   : integral_constant<bool,
 136                       (has_trivial_destructor<T>::value &&
 137                        has_trivial_destructor<U>::value)> { };
 138 template <class A, int N> struct has_trivial_destructor<A[N]>
 139   : has_trivial_destructor<A> { };
 140 template <class T> struct has_trivial_destructor<const T>
 141   : has_trivial_destructor<T> { };
 142
 143 // Specified by TR1 [4.7.1]
 144 template<typename T> struct remove_const { typedef T type; };
 145 template<typename T> struct remove_const<T const> { typedef T type; };
 146 template<typename T> struct remove_volatile { typedef T type; };
 147 template<typename T> struct remove_volatile<T volatile> { typedef T type; };
 148 template<typename T> struct remove_cv {
 149   typedef typename remove_const<typename remove_volatile<T>::type>::type type;
 150 };
 151
 152
 153 // Specified by TR1 [4.7.2]
 154 template<typename T> struct remove_reference { typedef T type; };
 155 template<typename T> struct remove_reference<T&> { typedef T type; };
 156
 157 // Specified by TR1 [4.7.4] Pointer modifications.
 158 template<typename T> struct remove_pointer { typedef T type; };
 159 template<typename T> struct remove_pointer<T*> { typedef T type; };
 160 template<typename T> struct remove_pointer<T* const> { typedef T type; };
 161 template<typename T> struct remove_pointer<T* volatile> { typedef T type; };
 162 template<typename T> struct remove_pointer<T* const volatile> {
 163   typedef T type; };
 164
 165 // Specified by TR1 [4.6] Relationships between types
 166 #ifndef _MSC_VER
 167 namespace internal {
 168
 169 // This class is an implementation detail for is_convertible, and you
 170 // don't need to know how it works to use is_convertible. For those
 171 // who care: we declare two different functions, one whose argument is
 172 // of type To and one with a variadic argument list. We give them
 173 // return types of different size, so we can use sizeof to trick the
 174 // compiler into telling us which function it would have chosen if we
 175 // had called it with an argument of type From.  See Alexandrescu's
 176 // _Modern C++ Design_ for more details on this sort of trick.
 177
 178 template <typename From, typename To>
 179 struct ConvertHelper {
 180   static small_ Test(To);
 181   static big_ Test(...);
 182   static From Create();
 183 };
 184 }  // namespace internal
 185
 186 // Inherits from true_type if From is convertible to To, false_type otherwise.
 187 template <typename From, typename To>
 188 struct is_convertible
 189     : integral_constant<bool,
 190                         sizeof(internal::ConvertHelper<From, To>::Test(
 191                                   internal::ConvertHelper<From, To>::Create()))
 192                         == sizeof(small_)> {
 193 };
 194 #endif
 195
 196 } // Close namespace base
 197
 198 #endif  // BASE_TYPE_TRAITS_H_