OLD | NEW |
---|---|
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #ifndef BASE_TEMPLATE_UTIL_H_ | 5 #ifndef BASE_TEMPLATE_UTIL_H_ |
6 #define BASE_TEMPLATE_UTIL_H_ | 6 #define BASE_TEMPLATE_UTIL_H_ |
7 | 7 |
8 #include <stddef.h> | 8 #include <type_traits> |
9 | 9 |
10 #include "build/build_config.h" | 10 #include "build/build_config.h" |
11 | 11 |
12 namespace base { | 12 namespace base { |
13 | 13 |
14 // template definitions from tr1 | 14 template <class T> struct is_non_const_reference : std::false_type {}; |
15 | 15 template <class T> struct is_non_const_reference<T&> : std::true_type {}; |
16 template<class T, T v> | 16 template <class T> struct is_non_const_reference<const T&> : std::false_type {}; |
17 struct integral_constant { | |
18 static const T value = v; | |
19 typedef T value_type; | |
20 typedef integral_constant<T, v> type; | |
21 }; | |
22 | |
23 template <class T, T v> const T integral_constant<T, v>::value; | |
24 | |
25 typedef integral_constant<bool, true> true_type; | |
26 typedef integral_constant<bool, false> false_type; | |
27 | |
28 template <class T> struct is_pointer : false_type {}; | |
29 template <class T> struct is_pointer<T*> : true_type {}; | |
30 | |
31 // Member function pointer detection. This is built-in to C++ 11's stdlib, and | |
32 // we can remove this when we switch to it. | |
33 template<typename T> | |
34 struct is_member_function_pointer : false_type {}; | |
35 | |
36 template <typename R, typename Z, typename... A> | |
37 struct is_member_function_pointer<R(Z::*)(A...)> : true_type {}; | |
38 template <typename R, typename Z, typename... A> | |
39 struct is_member_function_pointer<R(Z::*)(A...) const> : true_type {}; | |
40 | |
41 | |
42 template <class T, class U> struct is_same : public false_type {}; | |
43 template <class T> struct is_same<T,T> : true_type {}; | |
44 | |
45 template<class> struct is_array : public false_type {}; | |
46 template<class T, size_t n> struct is_array<T[n]> : public true_type {}; | |
47 template<class T> struct is_array<T[]> : public true_type {}; | |
48 | |
49 template <class T> struct is_non_const_reference : false_type {}; | |
50 template <class T> struct is_non_const_reference<T&> : true_type {}; | |
51 template <class T> struct is_non_const_reference<const T&> : false_type {}; | |
52 | |
53 template <class T> struct is_const : false_type {}; | |
54 template <class T> struct is_const<const T> : true_type {}; | |
55 | |
56 template <class T> struct is_void : false_type {}; | |
57 template <> struct is_void<void> : true_type {}; | |
58 | 17 |
59 namespace internal { | 18 namespace internal { |
60 | 19 |
61 // Types YesType and NoType are guaranteed such that sizeof(YesType) < | 20 // Types YesType and NoType are guaranteed such that sizeof(YesType) < |
62 // sizeof(NoType). | 21 // sizeof(NoType). |
63 typedef char YesType; | 22 typedef char YesType; |
danakj
2016/03/08 00:23:35
Can we move these to callback_internal.h?
tzik
2016/03/08 13:13:51
Done.
| |
64 | 23 |
65 struct NoType { | 24 struct NoType { |
66 YesType dummy[2]; | 25 YesType dummy[2]; |
67 }; | 26 }; |
68 | 27 |
69 // This class is an implementation detail for is_convertible, and you | |
70 // don't need to know how it works to use is_convertible. For those | |
71 // who care: we declare two different functions, one whose argument is | |
72 // of type To and one with a variadic argument list. We give them | |
73 // return types of different size, so we can use sizeof to trick the | |
74 // compiler into telling us which function it would have chosen if we | |
75 // had called it with an argument of type From. See Alexandrescu's | |
76 // _Modern C++ Design_ for more details on this sort of trick. | |
77 | |
78 struct ConvertHelper { | |
79 template <typename To> | |
80 static YesType Test(To); | |
81 | |
82 template <typename To> | |
83 static NoType Test(...); | |
84 | |
85 template <typename From> | |
86 static From& Create(); | |
87 }; | |
88 | |
89 // Used to determine if a type is a struct/union/class. Inspired by Boost's | |
90 // is_class type_trait implementation. | |
91 struct IsClassHelper { | |
92 template <typename C> | |
93 static YesType Test(void(C::*)(void)); | |
94 | |
95 template <typename C> | |
96 static NoType Test(...); | |
97 }; | |
98 | |
99 } // namespace internal | 28 } // namespace internal |
100 | 29 |
101 // Inherits from true_type if From is convertible to To, false_type otherwise. | |
102 // | |
103 // Note that if the type is convertible, this will be a true_type REGARDLESS | |
104 // of whether or not the conversion would emit a warning. | |
105 template <typename From, typename To> | |
106 struct is_convertible | |
107 : integral_constant<bool, | |
108 sizeof(internal::ConvertHelper::Test<To>( | |
109 internal::ConvertHelper::Create<From>())) == | |
110 sizeof(internal::YesType)> { | |
111 }; | |
112 | |
113 template <typename T> | |
114 struct is_class | |
115 : integral_constant<bool, | |
116 sizeof(internal::IsClassHelper::Test<T>(0)) == | |
117 sizeof(internal::YesType)> { | |
118 }; | |
119 | |
120 } // namespace base | 30 } // namespace base |
121 | 31 |
122 #endif // BASE_TEMPLATE_UTIL_H_ | 32 #endif // BASE_TEMPLATE_UTIL_H_ |
OLD | NEW |