1 // Copyright (c) 2006, Google Inc. 2 // All rights reserved. 3 // 4 // Redistribution and use in source and binary forms, with or without 5 // modification, are permitted provided that the following conditions are 6 // met: 7 // 8 // * Redistributions of source code must retain the above copyright 9 // notice, this list of conditions and the following disclaimer. 10 // * Redistributions in binary form must reproduce the above 11 // copyright notice, this list of conditions and the following disclaimer 12 // in the documentation and/or other materials provided with the 13 // distribution. 14 // * Neither the name of Google Inc. nor the names of its 15 // contributors may be used to endorse or promote products derived from 16 // this software without specific prior written permission. 17 // 18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 30 // ---- 31 // Author: Matt Austern 32 // 33 // This code is compiled directly on many platforms, including client 34 // platforms like Windows, Mac, and embedded systems. Before making 35 // any changes here, make sure that you're not breaking any platforms. 36 // 37 // Define a small subset of tr1 type traits. The traits we define are: 38 // is_integral 39 // is_floating_point 40 // is_pointer 41 // is_enum 42 // is_reference 43 // is_pod 44 // has_trivial_constructor 45 // has_trivial_copy 46 // has_trivial_assign 47 // has_trivial_destructor 48 // remove_const 49 // remove_volatile 50 // remove_cv 51 // remove_reference 52 // add_reference 53 // remove_pointer 54 // is_same 55 // is_convertible 56 // We can add more type traits as required. 57 58 #ifndef GOOGLE_PROTOBUF_TYPE_TRAITS_H_ 59 #define GOOGLE_PROTOBUF_TYPE_TRAITS_H_ 60 61 #include <utility> // For pair 62 63 #include <google/protobuf/stubs/template_util.h> // For true_type and false_type 64 65 namespace google { 66 namespace protobuf { 67 namespace internal { 68 69 template <class T> struct is_integral; 70 template <class T> struct is_floating_point; 71 template <class T> struct is_pointer; 72 // MSVC can't compile this correctly, and neither can gcc 3.3.5 (at least) 73 #if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3) 74 // is_enum uses is_convertible, which is not available on MSVC. 75 template <class T> struct is_enum; 76 #endif 77 template <class T> struct is_reference; 78 template <class T> struct is_pod; 79 template <class T> struct has_trivial_constructor; 80 template <class T> struct has_trivial_copy; 81 template <class T> struct has_trivial_assign; 82 template <class T> struct has_trivial_destructor; 83 template <class T> struct remove_const; 84 template <class T> struct remove_volatile; 85 template <class T> struct remove_cv; 86 template <class T> struct remove_reference; 87 template <class T> struct add_reference; 88 template <class T> struct remove_pointer; 89 template <class T, class U> struct is_same; 90 #if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3) 91 template <class From, class To> struct is_convertible; 92 #endif 93 94 // is_integral is false except for the built-in integer types. A 95 // cv-qualified type is integral if and only if the underlying type is. 96 template <class T> struct is_integral : false_type { }; 97 template<> struct is_integral<bool> : true_type { }; 98 template<> struct is_integral<char> : true_type { }; 99 template<> struct is_integral<unsigned char> : true_type { }; 100 template<> struct is_integral<signed char> : true_type { }; 101 #if defined(_MSC_VER) 102 // wchar_t is not by default a distinct type from unsigned short in 103 // Microsoft C. 104 // See http://msdn2.microsoft.com/en-us/library/dh8che7s(VS.80).aspx 105 template<> struct is_integral<__wchar_t> : true_type { }; 106 #else 107 template<> struct is_integral<wchar_t> : true_type { }; 108 #endif 109 template<> struct is_integral<short> : true_type { }; 110 template<> struct is_integral<unsigned short> : true_type { }; 111 template<> struct is_integral<int> : true_type { }; 112 template<> struct is_integral<unsigned int> : true_type { }; 113 template<> struct is_integral<long> : true_type { }; 114 template<> struct is_integral<unsigned long> : true_type { }; 115 #ifdef HAVE_LONG_LONG 116 template<> struct is_integral<long long> : true_type { }; 117 template<> struct is_integral<unsigned long long> : true_type { }; 118 #endif 119 template <class T> struct is_integral<const T> : is_integral<T> { }; 120 template <class T> struct is_integral<volatile T> : is_integral<T> { }; 121 template <class T> struct is_integral<const volatile T> : is_integral<T> { }; 122 123 // is_floating_point is false except for the built-in floating-point types. 124 // A cv-qualified type is integral if and only if the underlying type is. 125 template <class T> struct is_floating_point : false_type { }; 126 template<> struct is_floating_point<float> : true_type { }; 127 template<> struct is_floating_point<double> : true_type { }; 128 template<> struct is_floating_point<long double> : true_type { }; 129 template <class T> struct is_floating_point<const T> 130 : is_floating_point<T> { }; 131 template <class T> struct is_floating_point<volatile T> 132 : is_floating_point<T> { }; 133 template <class T> struct is_floating_point<const volatile T> 134 : is_floating_point<T> { }; 135 136 // is_pointer is false except for pointer types. A cv-qualified type (e.g. 137 // "int* const", as opposed to "int const*") is cv-qualified if and only if 138 // the underlying type is. 139 template <class T> struct is_pointer : false_type { }; 140 template <class T> struct is_pointer<T*> : true_type { }; 141 template <class T> struct is_pointer<const T> : is_pointer<T> { }; 142 template <class T> struct is_pointer<volatile T> : is_pointer<T> { }; 143 template <class T> struct is_pointer<const volatile T> : is_pointer<T> { }; 144 145 #if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3) 146 147 namespace internal { 148 149 template <class T> struct is_class_or_union { 150 template <class U> static small_ tester(void (U::*)()); 151 template <class U> static big_ tester(...); 152 static const bool value = sizeof(tester<T>(0)) == sizeof(small_); 153 }; 154 155 // is_convertible chokes if the first argument is an array. That's why 156 // we use add_reference here. 157 template <bool NotUnum, class T> struct is_enum_impl 158 : is_convertible<typename add_reference<T>::type, int> { }; 159 160 template <class T> struct is_enum_impl<true, T> : false_type { }; 161 162 } // namespace internal 163 164 // Specified by TR1 [4.5.1] primary type categories. 165 166 // Implementation note: 167 // 168 // Each type is either void, integral, floating point, array, pointer, 169 // reference, member object pointer, member function pointer, enum, 170 // union or class. Out of these, only integral, floating point, reference, 171 // class and enum types are potentially convertible to int. Therefore, 172 // if a type is not a reference, integral, floating point or class and 173 // is convertible to int, it's a enum. Adding cv-qualification to a type 174 // does not change whether it's an enum. 175 // 176 // Is-convertible-to-int check is done only if all other checks pass, 177 // because it can't be used with some types (e.g. void or classes with 178 // inaccessible conversion operators). 179 template <class T> struct is_enum 180 : internal::is_enum_impl< 181 is_same<T, void>::value || 182 is_integral<T>::value || 183 is_floating_point<T>::value || 184 is_reference<T>::value || 185 internal::is_class_or_union<T>::value, 186 T> { }; 187 188 template <class T> struct is_enum<const T> : is_enum<T> { }; 189 template <class T> struct is_enum<volatile T> : is_enum<T> { }; 190 template <class T> struct is_enum<const volatile T> : is_enum<T> { }; 191 192 #endif 193 194 // is_reference is false except for reference types. 195 template<typename T> struct is_reference : false_type {}; 196 template<typename T> struct is_reference<T&> : true_type {}; 197 198 199 // We can't get is_pod right without compiler help, so fail conservatively. 200 // We will assume it's false except for arithmetic types, enumerations, 201 // pointers and cv-qualified versions thereof. Note that std::pair<T,U> 202 // is not a POD even if T and U are PODs. 203 template <class T> struct is_pod 204 : integral_constant<bool, (is_integral<T>::value || 205 is_floating_point<T>::value || 206 #if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3) 207 // is_enum is not available on MSVC. 208 is_enum<T>::value || 209 #endif 210 is_pointer<T>::value)> { }; 211 template <class T> struct is_pod<const T> : is_pod<T> { }; 212 template <class T> struct is_pod<volatile T> : is_pod<T> { }; 213 template <class T> struct is_pod<const volatile T> : is_pod<T> { }; 214 215 216 // We can't get has_trivial_constructor right without compiler help, so 217 // fail conservatively. We will assume it's false except for: (1) types 218 // for which is_pod is true. (2) std::pair of types with trivial 219 // constructors. (3) array of a type with a trivial constructor. 220 // (4) const versions thereof. 221 template <class T> struct has_trivial_constructor : is_pod<T> { }; 222 template <class T, class U> struct has_trivial_constructor<std::pair<T, U> > 223 : integral_constant<bool, 224 (has_trivial_constructor<T>::value && 225 has_trivial_constructor<U>::value)> { }; 226 template <class A, int N> struct has_trivial_constructor<A[N]> 227 : has_trivial_constructor<A> { }; 228 template <class T> struct has_trivial_constructor<const T> 229 : has_trivial_constructor<T> { }; 230 231 // We can't get has_trivial_copy right without compiler help, so fail 232 // conservatively. We will assume it's false except for: (1) types 233 // for which is_pod is true. (2) std::pair of types with trivial copy 234 // constructors. (3) array of a type with a trivial copy constructor. 235 // (4) const versions thereof. 236 template <class T> struct has_trivial_copy : is_pod<T> { }; 237 template <class T, class U> struct has_trivial_copy<std::pair<T, U> > 238 : integral_constant<bool, 239 (has_trivial_copy<T>::value && 240 has_trivial_copy<U>::value)> { }; 241 template <class A, int N> struct has_trivial_copy<A[N]> 242 : has_trivial_copy<A> { }; 243 template <class T> struct has_trivial_copy<const T> : has_trivial_copy<T> { }; 244 245 // We can't get has_trivial_assign right without compiler help, so fail 246 // conservatively. We will assume it's false except for: (1) types 247 // for which is_pod is true. (2) std::pair of types with trivial copy 248 // constructors. (3) array of a type with a trivial assign constructor. 249 template <class T> struct has_trivial_assign : is_pod<T> { }; 250 template <class T, class U> struct has_trivial_assign<std::pair<T, U> > 251 : integral_constant<bool, 252 (has_trivial_assign<T>::value && 253 has_trivial_assign<U>::value)> { }; 254 template <class A, int N> struct has_trivial_assign<A[N]> 255 : has_trivial_assign<A> { }; 256 257 // We can't get has_trivial_destructor right without compiler help, so 258 // fail conservatively. We will assume it's false except for: (1) types 259 // for which is_pod is true. (2) std::pair of types with trivial 260 // destructors. (3) array of a type with a trivial destructor. 261 // (4) const versions thereof. 262 template <class T> struct has_trivial_destructor : is_pod<T> { }; 263 template <class T, class U> struct has_trivial_destructor<std::pair<T, U> > 264 : integral_constant<bool, 265 (has_trivial_destructor<T>::value && 266 has_trivial_destructor<U>::value)> { }; 267 template <class A, int N> struct has_trivial_destructor<A[N]> 268 : has_trivial_destructor<A> { }; 269 template <class T> struct has_trivial_destructor<const T> 270 : has_trivial_destructor<T> { }; 271 272 // Specified by TR1 [4.7.1] 273 template<typename T> struct remove_const { typedef T type; }; 274 template<typename T> struct remove_const<T const> { typedef T type; }; 275 template<typename T> struct remove_volatile { typedef T type; }; 276 template<typename T> struct remove_volatile<T volatile> { typedef T type; }; 277 template<typename T> struct remove_cv { 278 typedef typename remove_const<typename remove_volatile<T>::type>::type type; 279 }; 280 281 282 // Specified by TR1 [4.7.2] Reference modifications. 283 template<typename T> struct remove_reference { typedef T type; }; 284 template<typename T> struct remove_reference<T&> { typedef T type; }; 285 286 template <typename T> struct add_reference { typedef T& type; }; 287 template <typename T> struct add_reference<T&> { typedef T& type; }; 288 289 // Specified by TR1 [4.7.4] Pointer modifications. 290 template<typename T> struct remove_pointer { typedef T type; }; 291 template<typename T> struct remove_pointer<T*> { typedef T type; }; 292 template<typename T> struct remove_pointer<T* const> { typedef T type; }; 293 template<typename T> struct remove_pointer<T* volatile> { typedef T type; }; 294 template<typename T> struct remove_pointer<T* const volatile> { 295 typedef T type; }; 296 297 // Specified by TR1 [4.6] Relationships between types 298 template<typename T, typename U> struct is_same : public false_type { }; 299 template<typename T> struct is_same<T, T> : public true_type { }; 300 301 // Specified by TR1 [4.6] Relationships between types 302 #if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3) 303 namespace internal { 304 305 // This class is an implementation detail for is_convertible, and you 306 // don't need to know how it works to use is_convertible. For those 307 // who care: we declare two different functions, one whose argument is 308 // of type To and one with a variadic argument list. We give them 309 // return types of different size, so we can use sizeof to trick the 310 // compiler into telling us which function it would have chosen if we 311 // had called it with an argument of type From. See Alexandrescu's 312 // _Modern C++ Design_ for more details on this sort of trick. 313 314 template <typename From, typename To> 315 struct ConvertHelper { 316 static small_ Test(To); 317 static big_ Test(...); 318 static From Create(); 319 }; 320 } // namespace internal 321 322 // Inherits from true_type if From is convertible to To, false_type otherwise. 323 template <typename From, typename To> 324 struct is_convertible 325 : integral_constant<bool, 326 sizeof(internal::ConvertHelper<From, To>::Test( 327 internal::ConvertHelper<From, To>::Create())) 328 == sizeof(small_)> { 329 }; 330 #endif 331 332 } // namespace internal 333 } // namespace protobuf 334 } // namespace google 335 336 #endif // GOOGLE_PROTOBUF_TYPE_TRAITS_H_ 337
