cpp_type_traits.h

来自「symbian上STL模板库的实现」· C头文件 代码 · 共 346 行

// The  -*- C++ -*- type traits classes for internal use in libstdc++

// Copyright (C) 2000, 2001, 2002, 2003, 2004 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 2, 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.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING.  If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.

// Written by Gabriel Dos Reis <[e-mail]>

/** @file cpp_type_traits.h
 *  This is an internal header file, included by other library headers.
 *  You should not attempt to use it directly.
 */

#ifndef _CPP_TYPE_TRAITS_H
#define _CPP_TYPE_TRAITS_H 1

//#pragma GCC system_header

//
// 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 <stl/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 ([e-mail]) 2000-03-06.
//

// NB: g++ can not compile these if declared within the class
// __is_pod itself.
namespace __gnu_internal
{
    typedef char __one;
    typedef char __two[2];

    template <typename _Tp>
        __one __test_type (int _Tp::*);
    template <typename _Tp>
        __two& __test_type (...);
} // namespace __gnu_internal

namespace std
{
    // Compare for equality of types.
    template<typename, typename>
        struct __are_same
        {
            enum
            {
                _M_type = 0
            };
        };

    template<typename _Tp>
        struct __are_same<_Tp, _Tp>
        {
            enum
            {
                _M_type = 1
            };
        };

    // Define a nested type if some predicate holds.
    template<typename, bool>
        struct __enable_if
        {
        };

    template<typename _Tp>
        struct __enable_if<_Tp, true>
        {
            typedef _Tp _M_type;
        };

    // Holds if the template-argument is a void type.
    template<typename _Tp>
        struct __is_void
        {
            enum
            {
                _M_type = 0
            };
        };

    template<>
        struct __is_void<void>
        {
            enum
            {
                _M_type = 1
            };
        };

    //
    // Integer types
    //
    template<typename _Tp>
        struct __is_integer
        {
            enum
            {
                _M_type = 0
            };
        };

    // Thirteen specializations (yes there are eleven standard integer
    // types; 'long long' and 'unsigned long long' are supported as
    // extensions)
    template<>
        struct __is_integer<bool>
        {
            enum
            {
                _M_type = 1
            };
        };

    template<>
        struct __is_integer<char>
        {
            enum
            {
                _M_type = 1
            };
        };

    template<>
        struct __is_integer<signed char>
        {
            enum
            {
                _M_type = 1
            };
        };

    template<>
        struct __is_integer<unsigned char>
        {
            enum
            {
                _M_type = 1
            };
        };

# ifdef _GLIBCXX_USE_WCHAR_T
    template<>
        struct __is_integer<wchar_t>
        {
            enum
            {
                _M_type = 1
            };
        };
# endif

    template<>
        struct __is_integer<short>
        {
            enum
            {
                _M_type = 1
            };
        };

    template<>
        struct __is_integer<unsigned short>
        {
            enum
            {
                _M_type = 1
            };
        };

    template<>
        struct __is_integer<int>
        {
            enum
            {
                _M_type = 1
            };
        };

    template<>
        struct __is_integer<unsigned int>
        {
            enum
            {
                _M_type = 1
            };
        };

    template<>
        struct __is_integer<long>
        {
            enum
            {
                _M_type = 1
            };
        };

    template<>
        struct __is_integer<unsigned long>
        {
            enum
            {
                _M_type = 1
            };
        };

    template<>
        struct __is_integer<long long>
        {
            enum
            {
                _M_type = 1
            };
        };

    template<>
        struct __is_integer<unsigned long long>
        {
            enum
            {
                _M_type = 1
            };
        };

    //
    // Floating point types
    //
    template<typename _Tp>
        struct __is_floating
        {
            enum
            {
                _M_type = 0
            };
        };

    // three specializations (float, double and 'long double')
    template<>
        struct __is_floating<float>
        {
            enum
            {
                _M_type = 1
            };
        };

    template<>
        struct __is_floating<double>
        {
            enum
            {
                _M_type = 1
            };
        };

    template<>
        struct __is_floating<long double>
        {
            enum
            {
                _M_type = 1
            };
        };

    //
    // An arithmetic type is an integer type or a floating point type
    //
    template<typename _Tp>
        struct __is_arithmetic
        {
            enum
            {
                _M_type = __is_integer<_Tp>::_M_type || __is_floating<_Tp>::_M_type
            };
        };

    //
    // A fundamental type is `void' or and arithmetic type
    //
    template<typename _Tp>
        struct __is_fundamental
        {
            enum
            {
                _M_type = __is_void<_Tp>::_M_type || __is_arithmetic<_Tp>::_M_type
            };
        };

    //
    // For the immediate use, the following is a good approximation
    //
    template<typename _Tp>
        struct __is_pod
        {
            enum
            {
                _M_type = (sizeof(__gnu_internal::__test_type<_Tp>(0))
                        != sizeof(__gnu_internal::__one))
            };
        };

} // namespace std

#endif //_CPP_TYPE_TRAITS_H