libstdc++-v3/include/bits/cpp_type_traits.h

   1 // The  -*- C++ -*- type traits classes for internal use in libstdc++
   2
   3 // Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005
   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 2, 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 // You should have received a copy of the GNU General Public License along
  18 // with this library; see the file COPYING.  If not, write to the Free
  19 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20 // USA.
  21
  22 // As a special exception, you may use this file as part of a free software
  23 // library without restriction.  Specifically, if other files instantiate
  24 // templates or use macros or inline functions from this file, or you compile
  25 // this file and link it with other files to produce an executable, this
  26 // file does not by itself cause the resulting executable to be covered by
  27 // the GNU General Public License.  This exception does not however
  28 // invalidate any other reasons why the executable file might be covered by
  29 // the GNU General Public License.
  30
  31 // Written by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr>
  32
  33 /** @file cpp_type_traits.h
  34  *  This is an internal header file, included by other library headers.
  35  *  You should not attempt to use it directly.
  36  */
  37
  38 #ifndef _CPP_TYPE_TRAITS_H
  39 #define _CPP_TYPE_TRAITS_H 1
  40
  41 #pragma GCC system_header
  42
  43 #include <bits/c++config.h>
  44
  45 //
  46 // This file provides some compile-time information about various types.
  47 // These representations were designed, on purpose, to be constant-expressions
  48 // and not types as found in <bits/type_traits.h>.  In particular, they
  49 // can be used in control structures and the optimizer hopefully will do
  50 // the obvious thing.
  51 //
  52 // Why integral expressions, and not functions nor types?
  53 // Firstly, these compile-time entities are used as template-arguments
  54 // so function return values won't work:  We need compile-time entities.
  55 // We're left with types and constant  integral expressions.
  56 // Secondly, from the point of view of ease of use, type-based compile-time
  57 // information is -not- *that* convenient.  On has to write lots of
  58 // overloaded functions and to hope that the compiler will select the right
  59 // one. As a net effect, the overall structure isn't very clear at first
  60 // glance.
  61 // Thirdly, partial ordering and overload resolution (of function templates)
  62 // is highly costly in terms of compiler-resource.  It is a Good Thing to
  63 // keep these resource consumption as least as possible.
  64 //
  65 // See valarray_array.h for a case use.
  66 //
  67 // -- Gaby (dosreis@cmla.ens-cachan.fr) 2000-03-06.
  68 //
  69 // Update 2005: types are also provided and <bits/type_traits.h> has been
  70 // removed.
  71 //
  72
  73 // NB: g++ can not compile these if declared within the class
  74 // __is_pod itself.
  75 namespace __gnu_internal
  76 {
  77   typedef char __one;
  78   typedef char __two[2];
  79
  80   template<typename _Tp>
  81   __one __test_type(int _Tp::*);
  82   template<typename _Tp>
  83   __two& __test_type(...);
  84 } // namespace __gnu_internal
  85
  86 // Forward declaration hack, should really include this from somewhere.
  87 namespace __gnu_cxx
  88 {
  89   template<typename _Iterator, typename _Container>
  90     class __normal_iterator;
  91 } // namespace __gnu_cxx
  92
  93 struct __true_type { };
  94 struct __false_type { };
  95
  96 namespace std
  97 {
  98   template<bool>
  99     struct __truth_type
 100     { typedef __false_type __type; };
 101
 102   template<>
 103     struct __truth_type<true>
 104     { typedef __true_type __type; };
 105
 106   template<class _Sp, class _Tp>
 107     struct __traitor
 108     {
 109       enum { __value = _Sp::__value || _Tp::__value };
 110       typedef typename __truth_type<__value>::__type __type;
 111     };
 112
 113   // Compare for equality of types.
 114   template<typename, typename>
 115     struct __are_same
 116     {
 117       enum { __value = 0 };
 118       typedef __false_type __type;
 119     };
 120
 121   template<typename _Tp>
 122     struct __are_same<_Tp, _Tp>
 123     {
 124       enum { __value = 1 };
 125       typedef __true_type __type;
 126     };
 127
 128   // Define a nested type if some predicate holds.
 129   template<typename, bool>
 130     struct __enable_if
 131     {
 132     };
 133
 134   template<typename _Tp>
 135     struct __enable_if<_Tp, true>
 136     {
 137       typedef _Tp __type;
 138     };
 139
 140   // Holds if the template-argument is a void type.
 141   template<typename _Tp>
 142     struct __is_void
 143     {
 144       enum { __value = 0 };
 145       typedef __false_type __type;
 146     };
 147
 148   template<>
 149     struct __is_void<void>
 150     {
 151       enum { __value = 1 };
 152       typedef __true_type __type;
 153     };
 154
 155   //
 156   // Integer types
 157   //
 158   template<typename _Tp>
 159     struct __is_integer
 160     {
 161       enum { __value = 0 };
 162       typedef __false_type __type;
 163     };
 164
 165   // Thirteen specializations (yes there are eleven standard integer
 166   // types; 'long long' and 'unsigned long long' are supported as
 167   // extensions)
 168   template<>
 169     struct __is_integer<bool>
 170     {
 171       enum { __value = 1 };
 172       typedef __true_type __type;
 173     };
 174
 175   template<>
 176     struct __is_integer<char>
 177     {
 178       enum { __value = 1 };
 179       typedef __true_type __type;
 180     };
 181
 182   template<>
 183     struct __is_integer<signed char>
 184     {
 185       enum { __value = 1 };
 186       typedef __true_type __type;
 187     };
 188
 189   template<>
 190     struct __is_integer<unsigned char>
 191     {
 192       enum { __value = 1 };
 193       typedef __true_type __type;
 194     };
 195
 196 # ifdef _GLIBCXX_USE_WCHAR_T
 197   template<>
 198     struct __is_integer<wchar_t>
 199     {
 200       enum { __value = 1 };
 201       typedef __true_type __type;
 202     };
 203 # endif
 204
 205   template<>
 206     struct __is_integer<short>
 207     {
 208       enum { __value = 1 };
 209       typedef __true_type __type;
 210     };
 211
 212   template<>
 213     struct __is_integer<unsigned short>
 214     {
 215       enum { __value = 1 };
 216       typedef __true_type __type;
 217     };
 218
 219   template<>
 220     struct __is_integer<int>
 221     {
 222       enum { __value = 1 };
 223       typedef __true_type __type;
 224     };
 225
 226   template<>
 227     struct __is_integer<unsigned int>
 228     {
 229       enum { __value = 1 };
 230       typedef __true_type __type;
 231     };
 232
 233   template<>
 234     struct __is_integer<long>
 235     {
 236       enum { __value = 1 };
 237       typedef __true_type __type;
 238     };
 239
 240   template<>
 241     struct __is_integer<unsigned long>
 242     {
 243       enum { __value = 1 };
 244       typedef __true_type __type;
 245     };
 246
 247   template<>
 248     struct __is_integer<long long>
 249     {
 250       enum { __value = 1 };
 251       typedef __true_type __type;
 252     };
 253
 254   template<>
 255     struct __is_integer<unsigned long long>
 256     {
 257       enum { __value = 1 };
 258       typedef __true_type __type;
 259     };
 260
 261   //
 262   // Floating point types
 263   //
 264   template<typename _Tp>
 265     struct __is_floating
 266     {
 267       enum { __value = 0 };
 268       typedef __false_type __type;
 269     };
 270
 271   // three specializations (float, double and 'long double')
 272   template<>
 273     struct __is_floating<float>
 274     {
 275       enum { __value = 1 };
 276       typedef __true_type __type;
 277     };
 278
 279   template<>
 280     struct __is_floating<double>
 281     {
 282       enum { __value = 1 };
 283       typedef __true_type __type;
 284     };
 285
 286   template<>
 287     struct __is_floating<long double>
 288     {
 289       enum { __value = 1 };
 290       typedef __true_type __type;
 291     };
 292
 293   //
 294   // Pointer types
 295   //
 296   template<typename _Tp>
 297     struct __is_pointer
 298     {
 299       enum { __value = 0 };
 300       typedef __false_type __type;
 301     };
 302
 303   template<typename _Tp>
 304     struct __is_pointer<_Tp*>
 305     {
 306       enum { __value = 1 };
 307       typedef __true_type __type;
 308     };
 309
 310   //
 311   // Normal iterator type
 312   //
 313   template<typename _Tp>
 314     struct __is_normal_iterator
 315     {
 316       enum { __value = 0 };
 317       typedef __false_type __type;
 318     };
 319
 320   template<typename _Iterator, typename _Container>
 321     struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
 322                                                               _Container> >
 323     {
 324       enum { __value = 1 };
 325       typedef __true_type __type;
 326     };
 327
 328   //
 329   // An arithmetic type is an integer type or a floating point type
 330   //
 331   template<typename _Tp>
 332     struct __is_arithmetic
 333     : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
 334     { };
 335
 336   //
 337   // A fundamental type is `void' or and arithmetic type
 338   //
 339   template<typename _Tp>
 340     struct __is_fundamental
 341     : public __traitor<__is_void<_Tp>, __is_arithmetic<_Tp> >
 342     { };
 343
 344   //
 345   // A scalar type is an arithmetic type or a pointer type
 346   //
 347   template<typename _Tp>
 348     struct __is_scalar
 349     : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
 350     { };
 351
 352   //
 353   // For the immediate use, the following is a good approximation
 354   //
 355   template<typename _Tp>
 356     struct __is_pod
 357     {
 358       enum
 359         {
 360           __value = (sizeof(__gnu_internal::__test_type<_Tp>(0))
 361                      != sizeof(__gnu_internal::__one))
 362         };
 363     };
 364
 365 } // namespace std
 366
 367 #endif //_CPP_TYPE_TRAITS_H