libstdc++

cpp_type_traits.h
Go to the documentation of this file.
1 // The -*- C++ -*- type traits classes for internal use in libstdc++
2
3 // Copyright (C) 2000-2013 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24
25 /** @file bits/cpp_type_traits.h
26 * This is an internal header file, included by other library headers.
27 * Do not attempt to use it directly. @headername{ext/type_traits}
28 */
29
30 // Written by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr>
31
32 #ifndef _CPP_TYPE_TRAITS_H
33 #define _CPP_TYPE_TRAITS_H 1
34
35 #pragma GCC system_header
36
37 #include <bits/c++config.h>
38
39 //
40 // This file provides some compile-time information about various types.
41 // These representations were designed, on purpose, to be constant-expressions
42 // and not types as found in <bits/type_traits.h>. In particular, they
43 // can be used in control structures and the optimizer hopefully will do
44 // the obvious thing.
45 //
46 // Why integral expressions, and not functions nor types?
47 // Firstly, these compile-time entities are used as template-arguments
48 // so function return values won't work: We need compile-time entities.
49 // We're left with types and constant integral expressions.
50 // Secondly, from the point of view of ease of use, type-based compile-time
51 // information is -not- *that* convenient. On has to write lots of
52 // overloaded functions and to hope that the compiler will select the right
53 // one. As a net effect, the overall structure isn't very clear at first
54 // glance.
55 // Thirdly, partial ordering and overload resolution (of function templates)
56 // is highly costly in terms of compiler-resource. It is a Good Thing to
57 // keep these resource consumption as least as possible.
58 //
59 // See valarray_array.h for a case use.
60 //
61 // -- Gaby (dosreis@cmla.ens-cachan.fr) 2000-03-06.
62 //
63 // Update 2005: types are also provided and <bits/type_traits.h> has been
64 // removed.
65 //
66
67 // Forward declaration hack, should really include this from somewhere.
68 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
69 {
70 _GLIBCXX_BEGIN_NAMESPACE_VERSION
71
72 template<typename _Iterator, typename _Container>
73 class __normal_iterator;
74
75 _GLIBCXX_END_NAMESPACE_VERSION
76 } // namespace
77
78 namespace std _GLIBCXX_VISIBILITY(default)
79 {
80 _GLIBCXX_BEGIN_NAMESPACE_VERSION
81
82 struct __true_type { };
83 struct __false_type { };
84
85 template<bool>
86 struct __truth_type
87 { typedef __false_type __type; };
88
89 template<>
90 struct __truth_type<true>
91 { typedef __true_type __type; };
92
93 // N.B. The conversions to bool are needed due to the issue
94 // explained in c++/19404.
95 template<class _Sp, class _Tp>
96 struct __traitor
97 {
98 enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
99 typedef typename __truth_type<__value>::__type __type;
100 };
101
102 // Compare for equality of types.
103 template<typename, typename>
104 struct __are_same
105 {
106 enum { __value = 0 };
107 typedef __false_type __type;
108 };
109
110 template<typename _Tp>
111 struct __are_same<_Tp, _Tp>
112 {
113 enum { __value = 1 };
114 typedef __true_type __type;
115 };
116
117 // Holds if the template-argument is a void type.
118 template<typename _Tp>
119 struct __is_void
120 {
121 enum { __value = 0 };
122 typedef __false_type __type;
123 };
124
125 template<>
126 struct __is_void<void>
127 {
128 enum { __value = 1 };
129 typedef __true_type __type;
130 };
131
132 //
133 // Integer types
134 //
135 template<typename _Tp>
136 struct __is_integer
137 {
138 enum { __value = 0 };
139 typedef __false_type __type;
140 };
141
142 // Thirteen specializations (yes there are eleven standard integer
143 // types; <em>long long</em> and <em>unsigned long long</em> are
144 // supported as extensions)
145 template<>
146 struct __is_integer<bool>
147 {
148 enum { __value = 1 };
149 typedef __true_type __type;
150 };
151
152 template<>
153 struct __is_integer<char>
154 {
155 enum { __value = 1 };
156 typedef __true_type __type;
157 };
158
159 template<>
160 struct __is_integer<signed char>
161 {
162 enum { __value = 1 };
163 typedef __true_type __type;
164 };
165
166 template<>
167 struct __is_integer<unsigned char>
168 {
169 enum { __value = 1 };
170 typedef __true_type __type;
171 };
172
173 # ifdef _GLIBCXX_USE_WCHAR_T
174 template<>
175 struct __is_integer<wchar_t>
176 {
177 enum { __value = 1 };
178 typedef __true_type __type;
179 };
180 # endif
181
182 #if __cplusplus >= 201103L
183 template<>
184 struct __is_integer<char16_t>
185 {
186 enum { __value = 1 };
187 typedef __true_type __type;
188 };
189
190 template<>
191 struct __is_integer<char32_t>
192 {
193 enum { __value = 1 };
194 typedef __true_type __type;
195 };
196 #endif
197
198 template<>
199 struct __is_integer<short>
200 {
201 enum { __value = 1 };
202 typedef __true_type __type;
203 };
204
205 template<>
206 struct __is_integer<unsigned short>
207 {
208 enum { __value = 1 };
209 typedef __true_type __type;
210 };
211
212 template<>
213 struct __is_integer<int>
214 {
215 enum { __value = 1 };
216 typedef __true_type __type;
217 };
218
219 template<>
220 struct __is_integer<unsigned int>
221 {
222 enum { __value = 1 };
223 typedef __true_type __type;
224 };
225
226 template<>
227 struct __is_integer<long>
228 {
229 enum { __value = 1 };
230 typedef __true_type __type;
231 };
232
233 template<>
234 struct __is_integer<unsigned long>
235 {
236 enum { __value = 1 };
237 typedef __true_type __type;
238 };
239
240 template<>
241 struct __is_integer<long long>
242 {
243 enum { __value = 1 };
244 typedef __true_type __type;
245 };
246
247 template<>
248 struct __is_integer<unsigned long long>
249 {
250 enum { __value = 1 };
251 typedef __true_type __type;
252 };
253
254 //
255 // Floating point types
256 //
257 template<typename _Tp>
258 struct __is_floating
259 {
260 enum { __value = 0 };
261 typedef __false_type __type;
262 };
263
264 // three specializations (float, double and 'long double')
265 template<>
266 struct __is_floating<float>
267 {
268 enum { __value = 1 };
269 typedef __true_type __type;
270 };
271
272 template<>
273 struct __is_floating<double>
274 {
275 enum { __value = 1 };
276 typedef __true_type __type;
277 };
278
279 template<>
280 struct __is_floating<long double>
281 {
282 enum { __value = 1 };
283 typedef __true_type __type;
284 };
285
286 //
287 // Pointer types
288 //
289 template<typename _Tp>
290 struct __is_pointer
291 {
292 enum { __value = 0 };
293 typedef __false_type __type;
294 };
295
296 template<typename _Tp>
297 struct __is_pointer<_Tp*>
298 {
299 enum { __value = 1 };
300 typedef __true_type __type;
301 };
302
303 //
304 // Normal iterator type
305 //
306 template<typename _Tp>
307 struct __is_normal_iterator
308 {
309 enum { __value = 0 };
310 typedef __false_type __type;
311 };
312
313 template<typename _Iterator, typename _Container>
314 struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
315 _Container> >
316 {
317 enum { __value = 1 };
318 typedef __true_type __type;
319 };
320
321 //
322 // An arithmetic type is an integer type or a floating point type
323 //
324 template<typename _Tp>
325 struct __is_arithmetic
326 : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
327 { };
328
329 //
330 // A fundamental type is `void' or and arithmetic type
331 //
332 template<typename _Tp>
333 struct __is_fundamental
334 : public __traitor<__is_void<_Tp>, __is_arithmetic<_Tp> >
335 { };
336
337 //
338 // A scalar type is an arithmetic type or a pointer type
339 //
340 template<typename _Tp>
341 struct __is_scalar
342 : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
343 { };
344
345 //
346 // For use in std::copy and std::find overloads for streambuf iterators.
347 //
348 template<typename _Tp>
349 struct __is_char
350 {
351 enum { __value = 0 };
352 typedef __false_type __type;
353 };
354
355 template<>
356 struct __is_char<char>
357 {
358 enum { __value = 1 };
359 typedef __true_type __type;
360 };
361
362 #ifdef _GLIBCXX_USE_WCHAR_T
363 template<>
364 struct __is_char<wchar_t>
365 {
366 enum { __value = 1 };
367 typedef __true_type __type;
368 };
369 #endif
370
371 template<typename _Tp>
372 struct __is_byte
373 {
374 enum { __value = 0 };
375 typedef __false_type __type;
376 };
377
378 template<>
379 struct __is_byte<char>
380 {
381 enum { __value = 1 };
382 typedef __true_type __type;
383 };
384
385 template<>
386 struct __is_byte<signed char>
387 {
388 enum { __value = 1 };
389 typedef __true_type __type;
390 };
391
392 template<>
393 struct __is_byte<unsigned char>
394 {
395 enum { __value = 1 };
396 typedef __true_type __type;
397 };
398
399 //
400 // Move iterator type
401 //
402 template<typename _Tp>
403 struct __is_move_iterator
404 {
405 enum { __value = 0 };
406 typedef __false_type __type;
407 };
408
409 #if __cplusplus >= 201103L
410 template<typename _Iterator>
411 class move_iterator;
412
413 template<typename _Iterator>
414 struct __is_move_iterator< move_iterator<_Iterator> >
415 {
416 enum { __value = 1 };
417 typedef __true_type __type;
418 };
419 #endif
420
421 _GLIBCXX_END_NAMESPACE_VERSION
422 } // namespace
423
424 #endif //_CPP_TYPE_TRAITS_H