340 lines
12 KiB
C++
340 lines
12 KiB
C++
// Type traits implementation -*- C++ -*-
|
|
|
|
// Copyright (C) 2001 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.
|
|
|
|
/*
|
|
*
|
|
* Copyright (c) 1997
|
|
* Silicon Graphics Computer Systems, Inc.
|
|
*
|
|
* Permission to use, copy, modify, distribute and sell this software
|
|
* and its documentation for any purpose is hereby granted without fee,
|
|
* provided that the above copyright notice appear in all copies and
|
|
* that both that copyright notice and this permission notice appear
|
|
* in supporting documentation. Silicon Graphics makes no
|
|
* representations about the suitability of this software for any
|
|
* purpose. It is provided "as is" without express or implied warranty.
|
|
*/
|
|
|
|
/** @file type_traits.h
|
|
* This is an internal header file, included by other library headers.
|
|
* You should not attempt to use it directly.
|
|
*/
|
|
|
|
#ifndef _CPP_BITS_TYPE_TRAITS_H
|
|
#define _CPP_BITS_TYPE_TRAITS_H 1
|
|
|
|
#pragma GCC system_header
|
|
|
|
#include <bits/c++config.h>
|
|
|
|
/*
|
|
This header file provides a framework for allowing compile time dispatch
|
|
based on type attributes. This is useful when writing template code.
|
|
For example, when making a copy of an array of an unknown type, it helps
|
|
to know if the type has a trivial copy constructor or not, to help decide
|
|
if a memcpy can be used.
|
|
|
|
The class template __type_traits provides a series of typedefs each of
|
|
which is either __true_type or __false_type. The argument to
|
|
__type_traits can be any type. The typedefs within this template will
|
|
attain their correct values by one of these means:
|
|
1. The general instantiation contain conservative values which work
|
|
for all types.
|
|
2. Specializations may be declared to make distinctions between types.
|
|
3. Some compilers (such as the Silicon Graphics N32 and N64 compilers)
|
|
will automatically provide the appropriate specializations for all
|
|
types.
|
|
|
|
EXAMPLE:
|
|
|
|
//Copy an array of elements which have non-trivial copy constructors
|
|
template <class _Tp> void
|
|
copy(_Tp* __source,_Tp* __destination,int __n,__false_type);
|
|
//Copy an array of elements which have trivial copy constructors. Use memcpy.
|
|
template <class _Tp> void
|
|
copy(_Tp* __source,_Tp* __destination,int __n,__true_type);
|
|
|
|
//Copy an array of any type by using the most efficient copy mechanism
|
|
template <class _Tp> inline void copy(_Tp* __source,_Tp* __destination,int __n) {
|
|
copy(__source,__destination,__n,
|
|
typename __type_traits<_Tp>::has_trivial_copy_constructor());
|
|
}
|
|
*/
|
|
|
|
struct __true_type {};
|
|
struct __false_type {};
|
|
|
|
template <class _Tp>
|
|
struct __type_traits {
|
|
typedef __true_type this_dummy_member_must_be_first;
|
|
/* Do not remove this member. It informs a compiler which
|
|
automatically specializes __type_traits that this
|
|
__type_traits template is special. It just makes sure that
|
|
things work if an implementation is using a template
|
|
called __type_traits for something unrelated. */
|
|
|
|
/* The following restrictions should be observed for the sake of
|
|
compilers which automatically produce type specific specializations
|
|
of this class:
|
|
- You may reorder the members below if you wish
|
|
- You may remove any of the members below if you wish
|
|
- You must not rename members without making the corresponding
|
|
name change in the compiler
|
|
- Members you add will be treated like regular members unless
|
|
you add the appropriate support in the compiler. */
|
|
|
|
|
|
typedef __false_type has_trivial_default_constructor;
|
|
typedef __false_type has_trivial_copy_constructor;
|
|
typedef __false_type has_trivial_assignment_operator;
|
|
typedef __false_type has_trivial_destructor;
|
|
typedef __false_type is_POD_type;
|
|
};
|
|
|
|
|
|
// Provide some specializations.
|
|
|
|
template<> struct __type_traits<bool> {
|
|
typedef __true_type has_trivial_default_constructor;
|
|
typedef __true_type has_trivial_copy_constructor;
|
|
typedef __true_type has_trivial_assignment_operator;
|
|
typedef __true_type has_trivial_destructor;
|
|
typedef __true_type is_POD_type;
|
|
};
|
|
|
|
template<> struct __type_traits<char> {
|
|
typedef __true_type has_trivial_default_constructor;
|
|
typedef __true_type has_trivial_copy_constructor;
|
|
typedef __true_type has_trivial_assignment_operator;
|
|
typedef __true_type has_trivial_destructor;
|
|
typedef __true_type is_POD_type;
|
|
};
|
|
|
|
template<> struct __type_traits<signed char> {
|
|
typedef __true_type has_trivial_default_constructor;
|
|
typedef __true_type has_trivial_copy_constructor;
|
|
typedef __true_type has_trivial_assignment_operator;
|
|
typedef __true_type has_trivial_destructor;
|
|
typedef __true_type is_POD_type;
|
|
};
|
|
|
|
template<> struct __type_traits<unsigned char> {
|
|
typedef __true_type has_trivial_default_constructor;
|
|
typedef __true_type has_trivial_copy_constructor;
|
|
typedef __true_type has_trivial_assignment_operator;
|
|
typedef __true_type has_trivial_destructor;
|
|
typedef __true_type is_POD_type;
|
|
};
|
|
|
|
template<> struct __type_traits<wchar_t> {
|
|
typedef __true_type has_trivial_default_constructor;
|
|
typedef __true_type has_trivial_copy_constructor;
|
|
typedef __true_type has_trivial_assignment_operator;
|
|
typedef __true_type has_trivial_destructor;
|
|
typedef __true_type is_POD_type;
|
|
};
|
|
|
|
template<> struct __type_traits<short> {
|
|
typedef __true_type has_trivial_default_constructor;
|
|
typedef __true_type has_trivial_copy_constructor;
|
|
typedef __true_type has_trivial_assignment_operator;
|
|
typedef __true_type has_trivial_destructor;
|
|
typedef __true_type is_POD_type;
|
|
};
|
|
|
|
template<> struct __type_traits<unsigned short> {
|
|
typedef __true_type has_trivial_default_constructor;
|
|
typedef __true_type has_trivial_copy_constructor;
|
|
typedef __true_type has_trivial_assignment_operator;
|
|
typedef __true_type has_trivial_destructor;
|
|
typedef __true_type is_POD_type;
|
|
};
|
|
|
|
template<> struct __type_traits<int> {
|
|
typedef __true_type has_trivial_default_constructor;
|
|
typedef __true_type has_trivial_copy_constructor;
|
|
typedef __true_type has_trivial_assignment_operator;
|
|
typedef __true_type has_trivial_destructor;
|
|
typedef __true_type is_POD_type;
|
|
};
|
|
|
|
template<> struct __type_traits<unsigned int> {
|
|
typedef __true_type has_trivial_default_constructor;
|
|
typedef __true_type has_trivial_copy_constructor;
|
|
typedef __true_type has_trivial_assignment_operator;
|
|
typedef __true_type has_trivial_destructor;
|
|
typedef __true_type is_POD_type;
|
|
};
|
|
|
|
template<> struct __type_traits<long> {
|
|
typedef __true_type has_trivial_default_constructor;
|
|
typedef __true_type has_trivial_copy_constructor;
|
|
typedef __true_type has_trivial_assignment_operator;
|
|
typedef __true_type has_trivial_destructor;
|
|
typedef __true_type is_POD_type;
|
|
};
|
|
|
|
template<> struct __type_traits<unsigned long> {
|
|
typedef __true_type has_trivial_default_constructor;
|
|
typedef __true_type has_trivial_copy_constructor;
|
|
typedef __true_type has_trivial_assignment_operator;
|
|
typedef __true_type has_trivial_destructor;
|
|
typedef __true_type is_POD_type;
|
|
};
|
|
|
|
template<> struct __type_traits<long long> {
|
|
typedef __true_type has_trivial_default_constructor;
|
|
typedef __true_type has_trivial_copy_constructor;
|
|
typedef __true_type has_trivial_assignment_operator;
|
|
typedef __true_type has_trivial_destructor;
|
|
typedef __true_type is_POD_type;
|
|
};
|
|
|
|
template<> struct __type_traits<unsigned long long> {
|
|
typedef __true_type has_trivial_default_constructor;
|
|
typedef __true_type has_trivial_copy_constructor;
|
|
typedef __true_type has_trivial_assignment_operator;
|
|
typedef __true_type has_trivial_destructor;
|
|
typedef __true_type is_POD_type;
|
|
};
|
|
|
|
template<> struct __type_traits<float> {
|
|
typedef __true_type has_trivial_default_constructor;
|
|
typedef __true_type has_trivial_copy_constructor;
|
|
typedef __true_type has_trivial_assignment_operator;
|
|
typedef __true_type has_trivial_destructor;
|
|
typedef __true_type is_POD_type;
|
|
};
|
|
|
|
template<> struct __type_traits<double> {
|
|
typedef __true_type has_trivial_default_constructor;
|
|
typedef __true_type has_trivial_copy_constructor;
|
|
typedef __true_type has_trivial_assignment_operator;
|
|
typedef __true_type has_trivial_destructor;
|
|
typedef __true_type is_POD_type;
|
|
};
|
|
|
|
template<> struct __type_traits<long double> {
|
|
typedef __true_type has_trivial_default_constructor;
|
|
typedef __true_type has_trivial_copy_constructor;
|
|
typedef __true_type has_trivial_assignment_operator;
|
|
typedef __true_type has_trivial_destructor;
|
|
typedef __true_type is_POD_type;
|
|
};
|
|
|
|
template <class _Tp>
|
|
struct __type_traits<_Tp*> {
|
|
typedef __true_type has_trivial_default_constructor;
|
|
typedef __true_type has_trivial_copy_constructor;
|
|
typedef __true_type has_trivial_assignment_operator;
|
|
typedef __true_type has_trivial_destructor;
|
|
typedef __true_type is_POD_type;
|
|
};
|
|
|
|
|
|
// The following could be written in terms of numeric_limits.
|
|
// We're doing it separately to reduce the number of dependencies.
|
|
|
|
template <class _Tp> struct _Is_integer {
|
|
typedef __false_type _Integral;
|
|
};
|
|
|
|
template<> struct _Is_integer<bool> {
|
|
typedef __true_type _Integral;
|
|
};
|
|
|
|
template<> struct _Is_integer<char> {
|
|
typedef __true_type _Integral;
|
|
};
|
|
|
|
template<> struct _Is_integer<signed char> {
|
|
typedef __true_type _Integral;
|
|
};
|
|
|
|
template<> struct _Is_integer<unsigned char> {
|
|
typedef __true_type _Integral;
|
|
};
|
|
|
|
template<> struct _Is_integer<wchar_t> {
|
|
typedef __true_type _Integral;
|
|
};
|
|
|
|
template<> struct _Is_integer<short> {
|
|
typedef __true_type _Integral;
|
|
};
|
|
|
|
template<> struct _Is_integer<unsigned short> {
|
|
typedef __true_type _Integral;
|
|
};
|
|
|
|
template<> struct _Is_integer<int> {
|
|
typedef __true_type _Integral;
|
|
};
|
|
|
|
template<> struct _Is_integer<unsigned int> {
|
|
typedef __true_type _Integral;
|
|
};
|
|
|
|
template<> struct _Is_integer<long> {
|
|
typedef __true_type _Integral;
|
|
};
|
|
|
|
template<> struct _Is_integer<unsigned long> {
|
|
typedef __true_type _Integral;
|
|
};
|
|
|
|
template<> struct _Is_integer<long long> {
|
|
typedef __true_type _Integral;
|
|
};
|
|
|
|
template<> struct _Is_integer<unsigned long long> {
|
|
typedef __true_type _Integral;
|
|
};
|
|
|
|
template<typename _Tp> struct _Is_normal_iterator {
|
|
typedef __false_type _Normal;
|
|
};
|
|
|
|
// Forward declaration hack, should really include this from somewhere.
|
|
namespace std
|
|
{
|
|
template<typename _Iterator, typename _Container> class __normal_iterator;
|
|
}
|
|
|
|
template<typename _Iterator, typename _Container>
|
|
struct _Is_normal_iterator< std::__normal_iterator<_Iterator, _Container> > {
|
|
typedef __true_type _Normal;
|
|
};
|
|
|
|
#endif /* _CPP_BITS_TYPE_TRAITS_H */
|
|
|
|
// Local Variables:
|
|
// mode:C++
|
|
// End:
|