URL https://opencores.org/ocsvn/altor32/altor32/trunk

Subversion Repositories altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [or1knd-elf/] [include/] [c++/] [4.8.0/] [bits/] [cpp_type_traits.h] - Blame information for rev 35

Details | Compare with Previous | View Log


// The  -*- C++ -*- type traits classes for internal use in libstdc++
 
// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
 
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
 
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.
 
/** @file bits/cpp_type_traits.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{ext/type_traits}
 */
 
// Written by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr>
 
#ifndef _CPP_TYPE_TRAITS_H
#define _CPP_TYPE_TRAITS_H 1
 
#pragma GCC system_header
 
#include <bits/c++config.h>
 
//
// This file provides some compile-time information about various types.
// These representations were designed, on purpose, to be constant-expressions
// and not types as found in <bits/type_traits.h>.  In particular, they
// can be used in control structures and the optimizer hopefully will do
// the obvious thing.
//
// Why integral expressions, and not functions nor types?
// Firstly, these compile-time entities are used as template-arguments
// so function return values won't work:  We need compile-time entities.
// We're left with types and constant  integral expressions.
// Secondly, from the point of view of ease of use, type-based compile-time
// information is -not- *that* convenient.  On has to write lots of
// overloaded functions and to hope that the compiler will select the right
// one. As a net effect, the overall structure isn't very clear at first
// glance.
// Thirdly, partial ordering and overload resolution (of function templates)
// is highly costly in terms of compiler-resource.  It is a Good Thing to
// keep these resource consumption as least as possible.
//
// See valarray_array.h for a case use.
//
// -- Gaby (dosreis@cmla.ens-cachan.fr) 2000-03-06.
//
// Update 2005: types are also provided and <bits/type_traits.h> has been
// removed.
//
 
// Forward declaration hack, should really include this from somewhere.
namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
 
  template<typename _Iterator, typename _Container>
    class __normal_iterator;
 
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
 
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
 
  struct __true_type { };
  struct __false_type { };
 
  template<bool>
    struct __truth_type
    { typedef __false_type __type; };
 
  template<>
    struct __truth_type<true>
    { typedef __true_type __type; };
 
  // N.B. The conversions to bool are needed due to the issue
  // explained in c++/19404.
  template<class _Sp, class _Tp>
    struct __traitor
    {
      enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
      typedef typename __truth_type<__value>::__type __type;
    };
 
  // Compare for equality of types.
  template<typename, typename>
    struct __are_same
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };
 
  template<typename _Tp>
    struct __are_same<_Tp, _Tp>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  // Holds if the template-argument is a void type.
  template<typename _Tp>
    struct __is_void
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };
 
  template<>
    struct __is_void<void>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  //
  // Integer types
  //
  template<typename _Tp>
    struct __is_integer
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };
 
  // Thirteen specializations (yes there are eleven standard integer
  // types; <em>long long</em> and <em>unsigned long long</em> are
  // supported as extensions)
  template<>
    struct __is_integer<bool>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  template<>
    struct __is_integer<char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  template<>
    struct __is_integer<signed char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  template<>
    struct __is_integer<unsigned char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
# ifdef _GLIBCXX_USE_WCHAR_T
  template<>
    struct __is_integer<wchar_t>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
# endif
 
#if __cplusplus >= 201103L
  template<>
    struct __is_integer<char16_t>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  template<>
    struct __is_integer<char32_t>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
#endif
 
  template<>
    struct __is_integer<short>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  template<>
    struct __is_integer<unsigned short>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  template<>
    struct __is_integer<int>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  template<>
    struct __is_integer<unsigned int>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  template<>
    struct __is_integer<long>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  template<>
    struct __is_integer<unsigned long>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  template<>
    struct __is_integer<long long>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  template<>
    struct __is_integer<unsigned long long>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  //
  // Floating point types
  //
  template<typename _Tp>
    struct __is_floating
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };
 
  // three specializations (float, double and 'long double')
  template<>
    struct __is_floating<float>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  template<>
    struct __is_floating<double>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  template<>
    struct __is_floating<long double>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  //
  // Pointer types
  //
  template<typename _Tp>
    struct __is_pointer
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };
 
  template<typename _Tp>
    struct __is_pointer<_Tp*>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  //
  // Normal iterator type
  //
  template<typename _Tp>
    struct __is_normal_iterator
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };
 
  template<typename _Iterator, typename _Container>
    struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
                                                              _Container> >
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  //
  // An arithmetic type is an integer type or a floating point type
  //
  template<typename _Tp>
    struct __is_arithmetic
    : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
    { };
 
  //
  // A fundamental type is `void' or and arithmetic type
  //
  template<typename _Tp>
    struct __is_fundamental
    : public __traitor<__is_void<_Tp>, __is_arithmetic<_Tp> >
    { };
 
  //
  // A scalar type is an arithmetic type or a pointer type
  // 
  template<typename _Tp>
    struct __is_scalar
    : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
    { };
 
  //
  // For use in std::copy and std::find overloads for streambuf iterators.
  //
  template<typename _Tp>
    struct __is_char
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };
 
  template<>
    struct __is_char<char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
#ifdef _GLIBCXX_USE_WCHAR_T
  template<>
    struct __is_char<wchar_t>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
#endif
 
  template<typename _Tp>
    struct __is_byte
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };
 
  template<>
    struct __is_byte<char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  template<>
    struct __is_byte<signed char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  template<>
    struct __is_byte<unsigned char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
 
  //
  // Move iterator type
  //
  template<typename _Tp>
    struct __is_move_iterator
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };
 
#if __cplusplus >= 201103L
  template<typename _Iterator>
    class move_iterator;
 
  template<typename _Iterator>
    struct __is_move_iterator< move_iterator<_Iterator> >
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
#endif
 
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
 
#endif //_CPP_TYPE_TRAITS_H

Browse

Tools

Subversion Repositories altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [or1knd-elf/] [include/] [c++/] [4.8.0/] [bits/] [cpp_type_traits.h] - Blame information for rev 35

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