contrib/gcc-3.4/libstdc++-v3/include/bits/type_traits.h

   1 // Type traits implementation -*- C++ -*-
   2
   3 // Copyright (C) 2001, 2004 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 2, 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 // You should have received a copy of the GNU General Public License along
  17 // with this library; see the file COPYING.  If not, write to the Free
  18 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19 // USA.
  20
  21 // As a special exception, you may use this file as part of a free software
  22 // library without restriction.  Specifically, if other files instantiate
  23 // templates or use macros or inline functions from this file, or you compile
  24 // this file and link it with other files to produce an executable, this
  25 // file does not by itself cause the resulting executable to be covered by
  26 // the GNU General Public License.  This exception does not however
  27 // invalidate any other reasons why the executable file might be covered by
  28 // the GNU General Public License.
  29
  30 /*
  31  *
  32  * Copyright (c) 1997
  33  * Silicon Graphics Computer Systems, Inc.
  34  *
  35  * Permission to use, copy, modify, distribute and sell this software
  36  * and its documentation for any purpose is hereby granted without fee,
  37  * provided that the above copyright notice appear in all copies and
  38  * that both that copyright notice and this permission notice appear
  39  * in supporting documentation.  Silicon Graphics makes no
  40  * representations about the suitability of this software for any
  41  * purpose.  It is provided "as is" without express or implied warranty.
  42  */
  43
  44 /** @file type_traits.h
  45  *  This is an internal header file, included by other library headers.
  46  *  You should not attempt to use it directly.
  47  */
  48
  49 #ifndef _TYPE_TRAITS_H
  50 #define _TYPE_TRAITS_H 1
  51
  52 #pragma GCC system_header
  53
  54 #include <bits/c++config.h>
  55
  56 /*
  57 This header file provides a framework for allowing compile time dispatch
  58 based on type attributes. This is useful when writing template code.
  59 For example, when making a copy of an array of an unknown type, it helps
  60 to know if the type has a trivial copy constructor or not, to help decide
  61 if a memcpy can be used.
  62
  63 The class template __type_traits provides a series of typedefs each of
  64 which is either __true_type or __false_type. The argument to
  65 __type_traits can be any type. The typedefs within this template will
  66 attain their correct values by one of these means:
  67     1. The general instantiation contain conservative values which work
  68        for all types.
  69     2. Specializations may be declared to make distinctions between types.
  70     3. Some compilers (such as the Silicon Graphics N32 and N64 compilers)
  71        will automatically provide the appropriate specializations for all
  72        types.
  73
  74 EXAMPLE:
  75
  76 //Copy an array of elements which have non-trivial copy constructors
  77 template <class _Tp> void
  78   copy(_Tp* __source,_Tp* __destination,int __n,__false_type);
  79 //Copy an array of elements which have trivial copy constructors. Use memcpy.
  80 template <class _Tp> void
  81   copy(_Tp* __source,_Tp* __destination,int __n,__true_type);
  82
  83 //Copy an array of any type by using the most efficient copy mechanism
  84 template <class _Tp> inline void copy(_Tp* __source,_Tp* __destination,int __n) {
  85    copy(__source,__destination,__n,
  86         typename __type_traits<_Tp>::has_trivial_copy_constructor());
  87 }
  88 */
  89
  90 struct __true_type {};
  91 struct __false_type {};
  92
  93 template <class _Tp>
  94   struct __type_traits
  95   {
  96     typedef __true_type     this_dummy_member_must_be_first;
  97     /* Do not remove this member. It informs a compiler which
  98        automatically specializes __type_traits that this
  99        __type_traits template is special. It just makes sure that
 100        things work if an implementation is using a template
 101        called __type_traits for something unrelated. */
 102
 103    /* The following restrictions should be observed for the sake of
 104       compilers which automatically produce type specific specializations
 105       of this class:
 106           - You may reorder the members below if you wish
 107           - You may remove any of the members below if you wish
 108           - You must not rename members without making the corresponding
 109             name change in the compiler
 110           - Members you add will be treated like regular members unless
 111             you add the appropriate support in the compiler. */
 112
 113
 114     typedef __false_type    has_trivial_default_constructor;
 115     typedef __false_type    has_trivial_copy_constructor;
 116     typedef __false_type    has_trivial_assignment_operator;
 117     typedef __false_type    has_trivial_destructor;
 118     typedef __false_type    is_POD_type;
 119   };
 120
 121
 122 // Provide some specializations.
 123
 124 template<>
 125   struct __type_traits<bool>
 126   {
 127     typedef __true_type    has_trivial_default_constructor;
 128     typedef __true_type    has_trivial_copy_constructor;
 129     typedef __true_type    has_trivial_assignment_operator;
 130     typedef __true_type    has_trivial_destructor;
 131     typedef __true_type    is_POD_type;
 132   };
 133
 134 template<>
 135   struct __type_traits<char>
 136   {
 137     typedef __true_type    has_trivial_default_constructor;
 138     typedef __true_type    has_trivial_copy_constructor;
 139     typedef __true_type    has_trivial_assignment_operator;
 140     typedef __true_type    has_trivial_destructor;
 141     typedef __true_type    is_POD_type;
 142   };
 143
 144 template<>
 145   struct __type_traits<signed char>
 146   {
 147     typedef __true_type    has_trivial_default_constructor;
 148     typedef __true_type    has_trivial_copy_constructor;
 149     typedef __true_type    has_trivial_assignment_operator;
 150     typedef __true_type    has_trivial_destructor;
 151     typedef __true_type    is_POD_type;
 152   };
 153
 154 template<>
 155   struct __type_traits<unsigned char>
 156   {
 157     typedef __true_type    has_trivial_default_constructor;
 158     typedef __true_type    has_trivial_copy_constructor;
 159     typedef __true_type    has_trivial_assignment_operator;
 160     typedef __true_type    has_trivial_destructor;
 161     typedef __true_type    is_POD_type;
 162   };
 163
 164 template<>
 165   struct __type_traits<wchar_t>
 166   {
 167     typedef __true_type    has_trivial_default_constructor;
 168     typedef __true_type    has_trivial_copy_constructor;
 169     typedef __true_type    has_trivial_assignment_operator;
 170     typedef __true_type    has_trivial_destructor;
 171     typedef __true_type    is_POD_type;
 172   };
 173
 174 template<>
 175   struct __type_traits<short>
 176   {
 177     typedef __true_type    has_trivial_default_constructor;
 178     typedef __true_type    has_trivial_copy_constructor;
 179     typedef __true_type    has_trivial_assignment_operator;
 180     typedef __true_type    has_trivial_destructor;
 181     typedef __true_type    is_POD_type;
 182   };
 183
 184 template<>
 185   struct __type_traits<unsigned short>
 186   {
 187     typedef __true_type    has_trivial_default_constructor;
 188     typedef __true_type    has_trivial_copy_constructor;
 189     typedef __true_type    has_trivial_assignment_operator;
 190     typedef __true_type    has_trivial_destructor;
 191     typedef __true_type    is_POD_type;
 192   };
 193
 194 template<>
 195   struct __type_traits<int>
 196   {
 197     typedef __true_type    has_trivial_default_constructor;
 198     typedef __true_type    has_trivial_copy_constructor;
 199     typedef __true_type    has_trivial_assignment_operator;
 200     typedef __true_type    has_trivial_destructor;
 201     typedef __true_type    is_POD_type;
 202   };
 203
 204 template<>
 205   struct __type_traits<unsigned int>
 206   {
 207     typedef __true_type    has_trivial_default_constructor;
 208     typedef __true_type    has_trivial_copy_constructor;
 209     typedef __true_type    has_trivial_assignment_operator;
 210     typedef __true_type    has_trivial_destructor;
 211     typedef __true_type    is_POD_type;
 212   };
 213
 214 template<>
 215   struct __type_traits<long>
 216   {
 217     typedef __true_type    has_trivial_default_constructor;
 218     typedef __true_type    has_trivial_copy_constructor;
 219     typedef __true_type    has_trivial_assignment_operator;
 220     typedef __true_type    has_trivial_destructor;
 221     typedef __true_type    is_POD_type;
 222   };
 223
 224 template<>
 225   struct __type_traits<unsigned long>
 226   {
 227     typedef __true_type    has_trivial_default_constructor;
 228     typedef __true_type    has_trivial_copy_constructor;
 229     typedef __true_type    has_trivial_assignment_operator;
 230     typedef __true_type    has_trivial_destructor;
 231     typedef __true_type    is_POD_type;
 232   };
 233
 234 template<>
 235   struct __type_traits<long long>
 236   {
 237     typedef __true_type    has_trivial_default_constructor;
 238     typedef __true_type    has_trivial_copy_constructor;
 239     typedef __true_type    has_trivial_assignment_operator;
 240     typedef __true_type    has_trivial_destructor;
 241     typedef __true_type    is_POD_type;
 242   };
 243
 244 template<>
 245   struct __type_traits<unsigned long long>
 246   {
 247     typedef __true_type    has_trivial_default_constructor;
 248     typedef __true_type    has_trivial_copy_constructor;
 249     typedef __true_type    has_trivial_assignment_operator;
 250     typedef __true_type    has_trivial_destructor;
 251     typedef __true_type    is_POD_type;
 252   };
 253
 254 template<>
 255   struct __type_traits<float>
 256   {
 257     typedef __true_type    has_trivial_default_constructor;
 258     typedef __true_type    has_trivial_copy_constructor;
 259     typedef __true_type    has_trivial_assignment_operator;
 260     typedef __true_type    has_trivial_destructor;
 261     typedef __true_type    is_POD_type;
 262   };
 263
 264 template<>
 265   struct __type_traits<double>
 266   {
 267     typedef __true_type    has_trivial_default_constructor;
 268     typedef __true_type    has_trivial_copy_constructor;
 269     typedef __true_type    has_trivial_assignment_operator;
 270     typedef __true_type    has_trivial_destructor;
 271     typedef __true_type    is_POD_type;
 272   };
 273
 274 template<>
 275   struct __type_traits<long double>
 276   {
 277     typedef __true_type    has_trivial_default_constructor;
 278     typedef __true_type    has_trivial_copy_constructor;
 279     typedef __true_type    has_trivial_assignment_operator;
 280     typedef __true_type    has_trivial_destructor;
 281     typedef __true_type    is_POD_type;
 282   };
 283
 284 template <class _Tp>
 285   struct __type_traits<_Tp*>
 286   {
 287     typedef __true_type    has_trivial_default_constructor;
 288     typedef __true_type    has_trivial_copy_constructor;
 289     typedef __true_type    has_trivial_assignment_operator;
 290     typedef __true_type    has_trivial_destructor;
 291     typedef __true_type    is_POD_type;
 292   };
 293
 294 // The following could be written in terms of numeric_limits.
 295 // We're doing it separately to reduce the number of dependencies.
 296
 297 template <class _Tp>
 298   struct _Is_integer
 299   {
 300     typedef __false_type _Integral;
 301   };
 302
 303 template<>
 304   struct _Is_integer<bool>
 305   {
 306     typedef __true_type _Integral;
 307   };
 308
 309 template<>
 310   struct _Is_integer<char>
 311   {
 312     typedef __true_type _Integral;
 313   };
 314
 315 template<>
 316   struct _Is_integer<signed char>
 317   {
 318     typedef __true_type _Integral;
 319   };
 320
 321 template<>
 322   struct _Is_integer<unsigned char>
 323   {
 324     typedef __true_type _Integral;
 325   };
 326
 327 template<>
 328   struct _Is_integer<wchar_t>
 329   {
 330     typedef __true_type _Integral;
 331   };
 332
 333 template<>
 334   struct _Is_integer<short>
 335   {
 336     typedef __true_type _Integral;
 337   };
 338
 339 template<>
 340   struct _Is_integer<unsigned short>
 341   {
 342     typedef __true_type _Integral;
 343   };
 344
 345 template<>
 346   struct _Is_integer<int>
 347   {
 348     typedef __true_type _Integral;
 349   };
 350
 351 template<>
 352   struct _Is_integer<unsigned int>
 353   {
 354     typedef __true_type _Integral;
 355   };
 356
 357 template<>
 358   struct _Is_integer<long>
 359   {
 360     typedef __true_type _Integral;
 361   };
 362
 363 template<>
 364   struct _Is_integer<unsigned long>
 365   {
 366     typedef __true_type _Integral;
 367   };
 368
 369 template<>
 370   struct _Is_integer<long long>
 371   {
 372     typedef __true_type _Integral;
 373   };
 374
 375 template<>
 376   struct _Is_integer<unsigned long long>
 377   {
 378     typedef __true_type _Integral;
 379   };
 380
 381 template<typename _Tp>
 382   struct _Is_normal_iterator
 383   {
 384     typedef __false_type _Normal;
 385   };
 386
 387 // Forward declaration hack, should really include this from somewhere.
 388 namespace __gnu_cxx
 389 {
 390   template<typename _Iterator, typename _Container>
 391     class __normal_iterator;
 392 }
 393
 394 template<typename _Iterator, typename _Container>
 395   struct _Is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
 396                                                            _Container> >
 397   {
 398     typedef __true_type _Normal;
 399   };
 400
 401 #endif /* _TYPE_TRAITS_H */
 402
 403 // Local Variables:
 404 // mode:C++
 405 // End: