Home Explore Help
Sign In
d3m3vilurr
/
sonyoss-vita-webkit
Watch 1
Star 0
Fork 0
Files Issues 0 Pull Requests 0 Wiki
Tree: 258510b7f3
Branches Tags
sonyoss-vita...
/
Source
/
WTF
/
wtf
/
TypeTraits.cpp

TypeTraits.cpp 9.8 KB
History Raw

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156 
  1.  /*
    2. 

  2.  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
    3. 

  3.  * Copyright (C) 2009, 2010 Google Inc. All rights reserved.
    4. 

  4.  *
    5. 

  5.  * This library is free software; you can redistribute it and/or
    6. 

  6.  * modify it under the terms of the GNU Library General Public
    7. 

  7.  * License as published by the Free Software Foundation; either
    8. 

  8.  * version 2 of the License, or (at your option) any later version.
    9. 

  9.  *
    10. 

  10.  * This library is distributed in the hope that it will be useful,
    11. 

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    12. 

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    13. 

  13.  * Library General Public License for more details.
    14. 

  14.  *
    15. 

  15.  * You should have received a copy of the GNU Library General Public License
    16. 

  16.  * along with this library; see the file COPYING.LIB.  If not, write to
    17. 

  17.  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    18. 

  18.  * Boston, MA 02110-1301, USA.
    19. 

  19.  *
    20. 

  20.  */
    21. 

  21. 

  22. #include "config.h"
    23. 

  23. #include "TypeTraits.h"
    24. 

  24. 

  25. #include "Assertions.h"
    26. 

  26. 

  27. namespace WTF {
    28. 

  28. 

  29. COMPILE_ASSERT(IsInteger<bool>::value, WTF_IsInteger_bool_true);
    30. 

  30. COMPILE_ASSERT(IsInteger<char>::value, WTF_IsInteger_char_true);
    31. 

  31. COMPILE_ASSERT(IsInteger<signed char>::value, WTF_IsInteger_signed_char_true);
    32. 

  32. COMPILE_ASSERT(IsInteger<unsigned char>::value, WTF_IsInteger_unsigned_char_true);
    33. 

  33. COMPILE_ASSERT(IsInteger<short>::value, WTF_IsInteger_short_true);
    34. 

  34. COMPILE_ASSERT(IsInteger<unsigned short>::value, WTF_IsInteger_unsigned_short_true);
    35. 

  35. COMPILE_ASSERT(IsInteger<int>::value, WTF_IsInteger_int_true);
    36. 

  36. COMPILE_ASSERT(IsInteger<unsigned int>::value, WTF_IsInteger_unsigned_int_true);
    37. 

  37. COMPILE_ASSERT(IsInteger<long>::value, WTF_IsInteger_long_true);
    38. 

  38. COMPILE_ASSERT(IsInteger<unsigned long>::value, WTF_IsInteger_unsigned_long_true);
    39. 

  39. COMPILE_ASSERT(IsInteger<long long>::value, WTF_IsInteger_long_long_true);
    40. 

  40. COMPILE_ASSERT(IsInteger<unsigned long long>::value, WTF_IsInteger_unsigned_long_long_true);
    41. 

  41. #if !COMPILER(MSVC) || defined(_NATIVE_WCHAR_T_DEFINED)
    42. 

  42. COMPILE_ASSERT(IsInteger<wchar_t>::value, WTF_IsInteger_wchar_t_true);
    43. 

  43. #endif
    44. 

  44. COMPILE_ASSERT(!IsInteger<char*>::value, WTF_IsInteger_char_pointer_false);
    45. 

  45. COMPILE_ASSERT(!IsInteger<const char*>::value, WTF_IsInteger_const_char_pointer_false);
    46. 

  46. COMPILE_ASSERT(!IsInteger<volatile char*>::value, WTF_IsInteger_volatile_char_pointer_false);
    47. 

  47. COMPILE_ASSERT(!IsInteger<double>::value, WTF_IsInteger_double_false);
    48. 

  48. COMPILE_ASSERT(!IsInteger<float>::value, WTF_IsInteger_float_false);
    49. 

  49. 

  50. COMPILE_ASSERT(IsFloatingPoint<float>::value, WTF_IsFloatingPoint_float_true);
    51. 

  51. COMPILE_ASSERT(IsFloatingPoint<double>::value, WTF_IsFloatingPoint_double_true);
    52. 

  52. COMPILE_ASSERT(IsFloatingPoint<long double>::value, WTF_IsFloatingPoint_long_double_true);
    53. 

  53. COMPILE_ASSERT(!IsFloatingPoint<int>::value, WTF_IsFloatingPoint_int_false);
    54. 

  54. 

  55. COMPILE_ASSERT(IsPod<bool>::value, WTF_IsPod_bool_true);
    56. 

  56. COMPILE_ASSERT(IsPod<char>::value, WTF_IsPod_char_true);
    57. 

  57. COMPILE_ASSERT(IsPod<signed char>::value, WTF_IsPod_signed_char_true);
    58. 

  58. COMPILE_ASSERT(IsPod<unsigned char>::value, WTF_IsPod_unsigned_char_true);
    59. 

  59. COMPILE_ASSERT(IsPod<short>::value, WTF_IsPod_short_true);
    60. 

  60. COMPILE_ASSERT(IsPod<unsigned short>::value, WTF_IsPod_unsigned_short_true);
    61. 

  61. COMPILE_ASSERT(IsPod<int>::value, WTF_IsPod_int_true);
    62. 

  62. COMPILE_ASSERT(IsPod<unsigned int>::value, WTF_IsPod_unsigned_int_true);
    63. 

  63. COMPILE_ASSERT(IsPod<long>::value, WTF_IsPod_long_true);
    64. 

  64. COMPILE_ASSERT(IsPod<unsigned long>::value, WTF_IsPod_unsigned_long_true);
    65. 

  65. COMPILE_ASSERT(IsPod<long long>::value, WTF_IsPod_long_long_true);
    66. 

  66. COMPILE_ASSERT(IsPod<unsigned long long>::value, WTF_IsPod_unsigned_long_long_true);
    67. 

  67. #if !COMPILER(MSVC) || defined(_NATIVE_WCHAR_T_DEFINED)
    68. 

  68. COMPILE_ASSERT(IsPod<wchar_t>::value, WTF_IsPod_wchar_t_true);
    69. 

  69. #endif
    70. 

  70. COMPILE_ASSERT(IsPod<char*>::value, WTF_IsPod_char_pointer_true);
    71. 

  71. COMPILE_ASSERT(IsPod<const char*>::value, WTF_IsPod_const_char_pointer_true);
    72. 

  72. COMPILE_ASSERT(IsPod<volatile char*>::value, WTF_IsPod_volatile_char_pointer_true);
    73. 

  73. COMPILE_ASSERT(IsPod<double>::value, WTF_IsPod_double_true);
    74. 

  74. COMPILE_ASSERT(IsPod<long double>::value, WTF_IsPod_long_double_true);
    75. 

  75. COMPILE_ASSERT(IsPod<float>::value, WTF_IsPod_float_true);
    76. 

  76. COMPILE_ASSERT(!IsPod<IsPod<bool> >::value, WTF_IsPod_struct_false);
    77. 

  77. 

  78. enum IsConvertibleToIntegerCheck { };
    79. 

  79. COMPILE_ASSERT(IsConvertibleToInteger<IsConvertibleToIntegerCheck>::value, WTF_IsConvertibleToInteger_enum_true);
    80. 

  80. COMPILE_ASSERT(IsConvertibleToInteger<bool>::value, WTF_IsConvertibleToInteger_bool_true);
    81. 

  81. COMPILE_ASSERT(IsConvertibleToInteger<char>::value, WTF_IsConvertibleToInteger_char_true);
    82. 

  82. COMPILE_ASSERT(IsConvertibleToInteger<signed char>::value, WTF_IsConvertibleToInteger_signed_char_true);
    83. 

  83. COMPILE_ASSERT(IsConvertibleToInteger<unsigned char>::value, WTF_IsConvertibleToInteger_unsigned_char_true);
    84. 

  84. COMPILE_ASSERT(IsConvertibleToInteger<short>::value, WTF_IsConvertibleToInteger_short_true);
    85. 

  85. COMPILE_ASSERT(IsConvertibleToInteger<unsigned short>::value, WTF_IsConvertibleToInteger_unsigned_short_true);
    86. 

  86. COMPILE_ASSERT(IsConvertibleToInteger<int>::value, WTF_IsConvertibleToInteger_int_true);
    87. 

  87. COMPILE_ASSERT(IsConvertibleToInteger<unsigned int>::value, WTF_IsConvertibleToInteger_unsigned_int_true);
    88. 

  88. COMPILE_ASSERT(IsConvertibleToInteger<long>::value, WTF_IsConvertibleToInteger_long_true);
    89. 

  89. COMPILE_ASSERT(IsConvertibleToInteger<unsigned long>::value, WTF_IsConvertibleToInteger_unsigned_long_true);
    90. 

  90. COMPILE_ASSERT(IsConvertibleToInteger<long long>::value, WTF_IsConvertibleToInteger_long_long_true);
    91. 

  91. COMPILE_ASSERT(IsConvertibleToInteger<unsigned long long>::value, WTF_IsConvertibleToInteger_unsigned_long_long_true);
    92. 

  92. #if !COMPILER(MSVC) || defined(_NATIVE_WCHAR_T_DEFINED)
    93. 

  93. COMPILE_ASSERT(IsConvertibleToInteger<wchar_t>::value, WTF_IsConvertibleToInteger_wchar_t_true);
    94. 

  94. #endif
    95. 

  95. COMPILE_ASSERT(IsConvertibleToInteger<double>::value, WTF_IsConvertibleToInteger_double_true);
    96. 

  96. COMPILE_ASSERT(IsConvertibleToInteger<long double>::value, WTF_IsConvertibleToInteger_long_double_true);
    97. 

  97. COMPILE_ASSERT(IsConvertibleToInteger<float>::value, WTF_IsConvertibleToInteger_float_true);
    98. 

  98. COMPILE_ASSERT(!IsConvertibleToInteger<char*>::value, WTF_IsConvertibleToInteger_char_pointer_false);
    99. 

  99. COMPILE_ASSERT(!IsConvertibleToInteger<const char*>::value, WTF_IsConvertibleToInteger_const_char_pointer_false);
    100. 

  100. COMPILE_ASSERT(!IsConvertibleToInteger<volatile char*>::value, WTF_IsConvertibleToInteger_volatile_char_pointer_false);
    101. 

  101. COMPILE_ASSERT(!IsConvertibleToInteger<IsConvertibleToInteger<bool> >::value, WTF_IsConvertibleToInteger_struct_false);
    102. 

  102. 

  103. COMPILE_ASSERT((IsSameType<bool, bool>::value), WTF_IsSameType_bool_true);
    104. 

  104. COMPILE_ASSERT((IsSameType<int*, int*>::value), WTF_IsSameType_int_pointer_true);
    105. 

  105. COMPILE_ASSERT((!IsSameType<int, int*>::value), WTF_IsSameType_int_int_pointer_false);
    106. 

  106. COMPILE_ASSERT((!IsSameType<bool, const bool>::value), WTF_IsSameType_const_change_false);
    107. 

  107. COMPILE_ASSERT((!IsSameType<bool, volatile bool>::value), WTF_IsSameType_volatile_change_false);
    108. 

  108. 

  109. template <typename T>
    110. 

  110. class TestBaseClass {
    111. 

  111. };
    112. 

  112. 

  113. class TestDerivedClass : public TestBaseClass<int> {
    114. 

  114. };
    115. 

  115. 

  116. COMPILE_ASSERT((IsSubclass<TestDerivedClass, TestBaseClass<int> >::value), WTF_Test_IsSubclass_Derived_From_Base);
    117. 

  117. COMPILE_ASSERT((!IsSubclass<TestBaseClass<int>, TestDerivedClass>::value), WTF_Test_IsSubclass_Base_From_Derived);
    118. 

  118. COMPILE_ASSERT((IsSubclassOfTemplate<TestDerivedClass, TestBaseClass>::value), WTF_Test_IsSubclassOfTemplate_Base_From_Derived);
    119. 

  119. COMPILE_ASSERT((IsSameType<RemoveTemplate<TestBaseClass<int>, TestBaseClass>::Type, int>::value), WTF_Test_RemoveTemplate);
    120. 

  120. COMPILE_ASSERT((IsSameType<RemoveTemplate<int, TestBaseClass>::Type, int>::value), WTF_Test_RemoveTemplate_WithoutTemplate);
    121. 

  121. 

  122. 

  123. COMPILE_ASSERT((IsSameType<bool, RemoveConst<const bool>::Type>::value), WTF_test_RemoveConst_const_bool);
    124. 

  124. COMPILE_ASSERT((!IsSameType<bool, RemoveConst<volatile bool>::Type>::value), WTF_test_RemoveConst_volatile_bool);
    125. 

  125. 

  126. COMPILE_ASSERT((IsSameType<bool, RemoveVolatile<bool>::Type>::value), WTF_test_RemoveVolatile_bool);
    127. 

  127. COMPILE_ASSERT((!IsSameType<bool, RemoveVolatile<const bool>::Type>::value), WTF_test_RemoveVolatile_const_bool);
    128. 

  128. COMPILE_ASSERT((IsSameType<bool, RemoveVolatile<volatile bool>::Type>::value), WTF_test_RemoveVolatile_volatile_bool);
    129. 

  129. 

  130. COMPILE_ASSERT((IsSameType<bool, RemoveConstVolatile<bool>::Type>::value), WTF_test_RemoveConstVolatile_bool);
    131. 

  131. COMPILE_ASSERT((IsSameType<bool, RemoveConstVolatile<const bool>::Type>::value), WTF_test_RemoveConstVolatile_const_bool);
    132. 

  132. COMPILE_ASSERT((IsSameType<bool, RemoveConstVolatile<volatile bool>::Type>::value), WTF_test_RemoveConstVolatile_volatile_bool);
    133. 

  133. COMPILE_ASSERT((IsSameType<bool, RemoveConstVolatile<const volatile bool>::Type>::value), WTF_test_RemoveConstVolatile_const_volatile_bool);
    134. 

  134. 

  135. COMPILE_ASSERT((IsSameType<int, RemovePointer<int>::Type>::value), WTF_Test_RemovePointer_int);
    136. 

  136. COMPILE_ASSERT((IsSameType<int, RemovePointer<int*>::Type>::value), WTF_Test_RemovePointer_int_pointer);
    137. 

  137. COMPILE_ASSERT((!IsSameType<int, RemovePointer<int**>::Type>::value), WTF_Test_RemovePointer_int_pointer_pointer);
    138. 

  138. 

  139. COMPILE_ASSERT((IsSameType<int, RemoveReference<int>::Type>::value), WTF_Test_RemoveReference_int);
    140. 

  140. COMPILE_ASSERT((IsSameType<int, RemoveReference<int&>::Type>::value), WTF_Test_RemoveReference_int_reference);
    141. 

  141. 

  142. 

  143. typedef int IntArray[];
    144. 

  144. typedef int IntArraySized[4];
    145. 

  145. 

  146. COMPILE_ASSERT((IsArray<IntArray>::value), WTF_Test_IsArray_int_array);
    147. 

  147. COMPILE_ASSERT((IsArray<IntArraySized>::value), WTF_Test_IsArray_int_sized_array);
    148. 

  148. 

  149. COMPILE_ASSERT((IsSameType<int, RemoveExtent<IntArray>::Type>::value), WTF_Test_RemoveExtent_int_array);
    150. 

  150. COMPILE_ASSERT((IsSameType<int, RemoveExtent<IntArraySized>::Type>::value), WTF_Test_RemoveReference_int_sized_array);
    151. 

  151. 

  152. COMPILE_ASSERT((IsSameType<int*, DecayArray<IntArray>::Type>::value), WTF_Test_DecayArray_int_array);
    153. 

  153. COMPILE_ASSERT((IsSameType<int*, DecayArray<IntArraySized>::Type>::value), WTF_Test_DecayArray_int_sized_array);
    154. 

  154. 

  155. } // namespace WTF
    156. 

  156.