cpp_type_traits.h

Go to the documentation of this file.
00001 // The  -*- C++ -*- type traits classes for internal use in libstdc++
00002 
00003 // Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
00004 // Free Software Foundation, Inc.
00005 //
00006 // This file is part of the GNU ISO C++ Library.  This library is free
00007 // software; you can redistribute it and/or modify it under the
00008 // terms of the GNU General Public License as published by the
00009 // Free Software Foundation; either version 2, or (at your option)
00010 // any later version.
00011 
00012 // This library is distributed in the hope that it will be useful,
00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015 // GNU General Public License for more details.
00016 
00017 // You should have received a copy of the GNU General Public License along
00018 // with this library; see the file COPYING.  If not, write to the Free
00019 // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
00020 // USA.
00021 
00022 // As a special exception, you may use this file as part of a free software
00023 // library without restriction.  Specifically, if other files instantiate
00024 // templates or use macros or inline functions from this file, or you compile
00025 // this file and link it with other files to produce an executable, this
00026 // file does not by itself cause the resulting executable to be covered by
00027 // the GNU General Public License.  This exception does not however
00028 // invalidate any other reasons why the executable file might be covered by
00029 // the GNU General Public License.
00030 
00031 /** @file cpp_type_traits.h
00032  *  This is an internal header file, included by other library headers.
00033  *  You should not attempt to use it directly.
00034  */
00035 
00036 // Written by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr>
00037 
00038 #ifndef _CPP_TYPE_TRAITS_H
00039 #define _CPP_TYPE_TRAITS_H 1
00040 
00041 #pragma GCC system_header
00042 
00043 #include <bits/c++config.h>
00044 
00045 //
00046 // This file provides some compile-time information about various types.
00047 // These representations were designed, on purpose, to be constant-expressions
00048 // and not types as found in <bits/type_traits.h>.  In particular, they
00049 // can be used in control structures and the optimizer hopefully will do
00050 // the obvious thing.
00051 //
00052 // Why integral expressions, and not functions nor types?
00053 // Firstly, these compile-time entities are used as template-arguments
00054 // so function return values won't work:  We need compile-time entities.
00055 // We're left with types and constant  integral expressions.
00056 // Secondly, from the point of view of ease of use, type-based compile-time
00057 // information is -not- *that* convenient.  On has to write lots of
00058 // overloaded functions and to hope that the compiler will select the right
00059 // one. As a net effect, the overall structure isn't very clear at first
00060 // glance.
00061 // Thirdly, partial ordering and overload resolution (of function templates)
00062 // is highly costly in terms of compiler-resource.  It is a Good Thing to
00063 // keep these resource consumption as least as possible.
00064 //
00065 // See valarray_array.h for a case use.
00066 //
00067 // -- Gaby (dosreis@cmla.ens-cachan.fr) 2000-03-06.
00068 //
00069 // Update 2005: types are also provided and <bits/type_traits.h> has been
00070 // removed.
00071 //
00072 
00073 // Forward declaration hack, should really include this from somewhere.
00074 _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
00075 
00076   template<typename _Iterator, typename _Container>
00077     class __normal_iterator;
00078 
00079 _GLIBCXX_END_NAMESPACE
00080 
00081 _GLIBCXX_BEGIN_NAMESPACE(std)
00082 
00083   struct __true_type { };
00084   struct __false_type { };
00085 
00086   template<bool>
00087     struct __truth_type
00088     { typedef __false_type __type; };
00089 
00090   template<>
00091     struct __truth_type<true>
00092     { typedef __true_type __type; };
00093 
00094   // N.B. The conversions to bool are needed due to the issue
00095   // explained in c++/19404.
00096   template<class _Sp, class _Tp>
00097     struct __traitor
00098     {
00099       enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
00100       typedef typename __truth_type<__value>::__type __type;
00101     };
00102 
00103   // Compare for equality of types.
00104   template<typename, typename>
00105     struct __are_same
00106     {
00107       enum { __value = 0 };
00108       typedef __false_type __type;
00109     };
00110 
00111   template<typename _Tp>
00112     struct __are_same<_Tp, _Tp>
00113     {
00114       enum { __value = 1 };
00115       typedef __true_type __type;
00116     };
00117 
00118   // Holds if the template-argument is a void type.
00119   template<typename _Tp>
00120     struct __is_void
00121     {
00122       enum { __value = 0 };
00123       typedef __false_type __type;
00124     };
00125 
00126   template<>
00127     struct __is_void<void>
00128     {
00129       enum { __value = 1 };
00130       typedef __true_type __type;
00131     };
00132 
00133   //
00134   // Integer types
00135   //
00136   template<typename _Tp>
00137     struct __is_integer
00138     {
00139       enum { __value = 0 };
00140       typedef __false_type __type;
00141     };
00142 
00143   // Thirteen specializations (yes there are eleven standard integer
00144   // types; 'long long' and 'unsigned long long' are supported as
00145   // extensions)
00146   template<>
00147     struct __is_integer<bool>
00148     {
00149       enum { __value = 1 };
00150       typedef __true_type __type;
00151     };
00152 
00153   template<>
00154     struct __is_integer<char>
00155     {
00156       enum { __value = 1 };
00157       typedef __true_type __type;
00158     };
00159 
00160   template<>
00161     struct __is_integer<signed char>
00162     {
00163       enum { __value = 1 };
00164       typedef __true_type __type;
00165     };
00166 
00167   template<>
00168     struct __is_integer<unsigned char>
00169     {
00170       enum { __value = 1 };
00171       typedef __true_type __type;
00172     };
00173 
00174 # ifdef _GLIBCXX_USE_WCHAR_T
00175   template<>
00176     struct __is_integer<wchar_t>
00177     {
00178       enum { __value = 1 };
00179       typedef __true_type __type;
00180     };
00181 # endif
00182 
00183   template<>
00184     struct __is_integer<short>
00185     {
00186       enum { __value = 1 };
00187       typedef __true_type __type;
00188     };
00189 
00190   template<>
00191     struct __is_integer<unsigned short>
00192     {
00193       enum { __value = 1 };
00194       typedef __true_type __type;
00195     };
00196 
00197   template<>
00198     struct __is_integer<int>
00199     {
00200       enum { __value = 1 };
00201       typedef __true_type __type;
00202     };
00203 
00204   template<>
00205     struct __is_integer<unsigned int>
00206     {
00207       enum { __value = 1 };
00208       typedef __true_type __type;
00209     };
00210 
00211   template<>
00212     struct __is_integer<long>
00213     {
00214       enum { __value = 1 };
00215       typedef __true_type __type;
00216     };
00217 
00218   template<>
00219     struct __is_integer<unsigned long>
00220     {
00221       enum { __value = 1 };
00222       typedef __true_type __type;
00223     };
00224 
00225   template<>
00226     struct __is_integer<long long>
00227     {
00228       enum { __value = 1 };
00229       typedef __true_type __type;
00230     };
00231 
00232   template<>
00233     struct __is_integer<unsigned long long>
00234     {
00235       enum { __value = 1 };
00236       typedef __true_type __type;
00237     };
00238 
00239   //
00240   // Floating point types
00241   //
00242   template<typename _Tp>
00243     struct __is_floating
00244     {
00245       enum { __value = 0 };
00246       typedef __false_type __type;
00247     };
00248 
00249   // three specializations (float, double and 'long double')
00250   template<>
00251     struct __is_floating<float>
00252     {
00253       enum { __value = 1 };
00254       typedef __true_type __type;
00255     };
00256 
00257   template<>
00258     struct __is_floating<double>
00259     {
00260       enum { __value = 1 };
00261       typedef __true_type __type;
00262     };
00263 
00264   template<>
00265     struct __is_floating<long double>
00266     {
00267       enum { __value = 1 };
00268       typedef __true_type __type;
00269     };
00270 
00271   //
00272   // Pointer types
00273   //
00274   template<typename _Tp>
00275     struct __is_pointer
00276     {
00277       enum { __value = 0 };
00278       typedef __false_type __type;
00279     };
00280 
00281   template<typename _Tp>
00282     struct __is_pointer<_Tp*>
00283     {
00284       enum { __value = 1 };
00285       typedef __true_type __type;
00286     };
00287 
00288   //
00289   // Normal iterator type
00290   //
00291   template<typename _Tp>
00292     struct __is_normal_iterator
00293     {
00294       enum { __value = 0 };
00295       typedef __false_type __type;
00296     };
00297 
00298   template<typename _Iterator, typename _Container>
00299     struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
00300                                   _Container> >
00301     {
00302       enum { __value = 1 };
00303       typedef __true_type __type;
00304     };
00305 
00306   //
00307   // An arithmetic type is an integer type or a floating point type
00308   //
00309   template<typename _Tp>
00310     struct __is_arithmetic
00311     : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
00312     { };
00313 
00314   //
00315   // A fundamental type is `void' or and arithmetic type
00316   //
00317   template<typename _Tp>
00318     struct __is_fundamental
00319     : public __traitor<__is_void<_Tp>, __is_arithmetic<_Tp> >
00320     { };
00321 
00322   //
00323   // A scalar type is an arithmetic type or a pointer type
00324   // 
00325   template<typename _Tp>
00326     struct __is_scalar
00327     : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
00328     { };
00329 
00330   //
00331   // For use in std::copy and std::find overloads for streambuf iterators.
00332   //
00333   template<typename _Tp>
00334     struct __is_char
00335     {
00336       enum { __value = 0 };
00337       typedef __false_type __type;
00338     };
00339 
00340   template<>
00341     struct __is_char<char>
00342     {
00343       enum { __value = 1 };
00344       typedef __true_type __type;
00345     };
00346 
00347 #ifdef _GLIBCXX_USE_WCHAR_T
00348   template<>
00349     struct __is_char<wchar_t>
00350     {
00351       enum { __value = 1 };
00352       typedef __true_type __type;
00353     };
00354 #endif
00355 
00356   template<typename _Tp>
00357     struct __is_byte
00358     {
00359       enum { __value = 0 };
00360       typedef __false_type __type;
00361     };
00362 
00363   template<>
00364     struct __is_byte<char>
00365     {
00366       enum { __value = 1 };
00367       typedef __true_type __type;
00368     };
00369 
00370   template<>
00371     struct __is_byte<signed char>
00372     {
00373       enum { __value = 1 };
00374       typedef __true_type __type;
00375     };
00376 
00377   template<>
00378     struct __is_byte<unsigned char>
00379     {
00380       enum { __value = 1 };
00381       typedef __true_type __type;
00382     };
00383 
00384   //
00385   // Move iterator type
00386   //
00387   template<typename _Tp>
00388     struct __is_move_iterator
00389     {
00390       enum { __value = 0 };
00391       typedef __false_type __type;
00392     };
00393 
00394 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00395   template<typename _Iterator>
00396     class move_iterator;
00397 
00398   template<typename _Iterator>
00399     struct __is_move_iterator< move_iterator<_Iterator> >
00400     {
00401       enum { __value = 1 };
00402       typedef __true_type __type;
00403     };
00404 #endif
00405 
00406 _GLIBCXX_END_NAMESPACE
00407 
00408 #endif //_CPP_TYPE_TRAITS_H

Generated on Wed Mar 26 00:42:56 2008 for libstdc++ by  doxygen 1.5.1