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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  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 _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
  88
  89   template<typename _Iterator, typename _Container>
  90     class __normal_iterator;
  91
  92 _GLIBCXX_END_NAMESPACE
  93
  94 struct __true_type { };
  95 struct __false_type { };
  96
  97 _GLIBCXX_BEGIN_NAMESPACE(std)
  98
  99   template<bool>
 100     struct __truth_type
 101     { typedef __false_type __type; };
 102
 103   template<>
 104     struct __truth_type<true>
 105     { typedef __true_type __type; };
 106
 107   // N.B. The conversions to bool are needed due to the issue
 108   // explained in c++/19404.
 109   template<class _Sp, class _Tp>
 110     struct __traitor
 111     {
 112       enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
 113       typedef typename __truth_type<__value>::__type __type;
 114     };
 115
 116   // Compare for equality of types.
 117   template<typename, typename>
 118     struct __are_same
 119     {
 120       enum { __value = 0 };
 121       typedef __false_type __type;
 122     };
 123
 124   template<typename _Tp>
 125     struct __are_same<_Tp, _Tp>
 126     {
 127       enum { __value = 1 };
 128       typedef __true_type __type;
 129     };
 130
 131   // Define a nested type if some predicate holds.
 132   template<typename, bool>
 133     struct __enable_if
 134     {
 135     };
 136
 137   template<typename _Tp>
 138     struct __enable_if<_Tp, true>
 139     {
 140       typedef _Tp __type;
 141     };
 142
 143   // Holds if the template-argument is a void type.
 144   template<typename _Tp>
 145     struct __is_void
 146     {
 147       enum { __value = 0 };
 148       typedef __false_type __type;
 149     };
 150
 151   template<>
 152     struct __is_void<void>
 153     {
 154       enum { __value = 1 };
 155       typedef __true_type __type;
 156     };
 157
 158   //
 159   // Integer types
 160   //
 161   template<typename _Tp>
 162     struct __is_integer
 163     {
 164       enum { __value = 0 };
 165       typedef __false_type __type;
 166     };
 167
 168   // Thirteen specializations (yes there are eleven standard integer
 169   // types; 'long long' and 'unsigned long long' are supported as
 170   // extensions)
 171   template<>
 172     struct __is_integer<bool>
 173     {
 174       enum { __value = 1 };
 175       typedef __true_type __type;
 176     };
 177
 178   template<>
 179     struct __is_integer<char>
 180     {
 181       enum { __value = 1 };
 182       typedef __true_type __type;
 183     };
 184
 185   template<>
 186     struct __is_integer<signed char>
 187     {
 188       enum { __value = 1 };
 189       typedef __true_type __type;
 190     };
 191
 192   template<>
 193     struct __is_integer<unsigned char>
 194     {
 195       enum { __value = 1 };
 196       typedef __true_type __type;
 197     };
 198
 199 # ifdef _GLIBCXX_USE_WCHAR_T
 200   template<>
 201     struct __is_integer<wchar_t>
 202     {
 203       enum { __value = 1 };
 204       typedef __true_type __type;
 205     };
 206 # endif
 207
 208   template<>
 209     struct __is_integer<short>
 210     {
 211       enum { __value = 1 };
 212       typedef __true_type __type;
 213     };
 214
 215   template<>
 216     struct __is_integer<unsigned short>
 217     {
 218       enum { __value = 1 };
 219       typedef __true_type __type;
 220     };
 221
 222   template<>
 223     struct __is_integer<int>
 224     {
 225       enum { __value = 1 };
 226       typedef __true_type __type;
 227     };
 228
 229   template<>
 230     struct __is_integer<unsigned int>
 231     {
 232       enum { __value = 1 };
 233       typedef __true_type __type;
 234     };
 235
 236   template<>
 237     struct __is_integer<long>
 238     {
 239       enum { __value = 1 };
 240       typedef __true_type __type;
 241     };
 242
 243   template<>
 244     struct __is_integer<unsigned long>
 245     {
 246       enum { __value = 1 };
 247       typedef __true_type __type;
 248     };
 249
 250   template<>
 251     struct __is_integer<long long>
 252     {
 253       enum { __value = 1 };
 254       typedef __true_type __type;
 255     };
 256
 257   template<>
 258     struct __is_integer<unsigned long long>
 259     {
 260       enum { __value = 1 };
 261       typedef __true_type __type;
 262     };
 263
 264   //
 265   // Floating point types
 266   //
 267   template<typename _Tp>
 268     struct __is_floating
 269     {
 270       enum { __value = 0 };
 271       typedef __false_type __type;
 272     };
 273
 274   // three specializations (float, double and 'long double')
 275   template<>
 276     struct __is_floating<float>
 277     {
 278       enum { __value = 1 };
 279       typedef __true_type __type;
 280     };
 281
 282   template<>
 283     struct __is_floating<double>
 284     {
 285       enum { __value = 1 };
 286       typedef __true_type __type;
 287     };
 288
 289   template<>
 290     struct __is_floating<long double>
 291     {
 292       enum { __value = 1 };
 293       typedef __true_type __type;
 294     };
 295
 296   //
 297   // Pointer types
 298   //
 299   template<typename _Tp>
 300     struct __is_pointer
 301     {
 302       enum { __value = 0 };
 303       typedef __false_type __type;
 304     };
 305
 306   template<typename _Tp>
 307     struct __is_pointer<_Tp*>
 308     {
 309       enum { __value = 1 };
 310       typedef __true_type __type;
 311     };
 312
 313   //
 314   // Normal iterator type
 315   //
 316   template<typename _Tp>
 317     struct __is_normal_iterator
 318     {
 319       enum { __value = 0 };
 320       typedef __false_type __type;
 321     };
 322
 323   template<typename _Iterator, typename _Container>
 324     struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
 325                                                               _Container> >
 326     {
 327       enum { __value = 1 };
 328       typedef __true_type __type;
 329     };
 330
 331   //
 332   // An arithmetic type is an integer type or a floating point type
 333   //
 334   template<typename _Tp>
 335     struct __is_arithmetic
 336     : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
 337     { };
 338
 339   //
 340   // A fundamental type is `void' or and arithmetic type
 341   //
 342   template<typename _Tp>
 343     struct __is_fundamental
 344     : public __traitor<__is_void<_Tp>, __is_arithmetic<_Tp> >
 345     { };
 346
 347   //
 348   // A scalar type is an arithmetic type or a pointer type
 349   //
 350   template<typename _Tp>
 351     struct __is_scalar
 352     : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
 353     { };
 354
 355   //
 356   // For the immediate use, the following is a good approximation
 357   //
 358   template<typename _Tp>
 359     struct __is_pod
 360     {
 361       enum
 362         {
 363           __value = (sizeof(__gnu_internal::__test_type<_Tp>(0))
 364                      != sizeof(__gnu_internal::__one))
 365         };
 366     };
 367
 368   //
 369   // A stripped-down version of std::tr1::is_empty
 370   //
 371   template<typename _Tp>
 372     struct __is_empty
 373     {
 374     private:
 375       template<typename>
 376         struct __first { };
 377       template<typename _Up>
 378         struct __second
 379         : public _Up { };
 380
 381     public:
 382       enum
 383         {
 384           __value = sizeof(__first<_Tp>) == sizeof(__second<_Tp>)
 385         };
 386     };
 387
 388 _GLIBCXX_END_NAMESPACE
 389
 390 #endif //_CPP_TYPE_TRAITS_H