Subversion Repositories Kolibri OS

/*

 *

 * 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.

 */

#ifndef _CPP_BITS_TYPE_TRAITS_H

#define _CPP_BITS_TYPE_TRAITS_H 1

#pragma GCC system_header

#include 

/*

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  void

  copy(_Tp* __source,_Tp* __destination,int __n,__false_type);

//Copy an array of elements which have trivial copy constructors. Use memcpy.

template  void

  copy(_Tp* __source,_Tp* __destination,int __n,__true_type);

//Copy an array of any type by using the most efficient copy mechanism

template  inline void copy(_Tp* __source,_Tp* __destination,int __n) {

   copy(__source,__destination,__n,

        typename __type_traits<_Tp>::has_trivial_copy_constructor());

}

*/

template  struct _Bool {};

typedef _Bool  __true_type;

typedef _Bool __false_type;

template 

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 {

   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 {

   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 {

   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 {

   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 {

   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 {

   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 {

   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 {

   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 {

   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 {

   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 {

   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;

};

#ifdef _GLIBCPP_USE_LONG_LONG

template<> struct __type_traits {

   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 {

   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;

};

#endif /* _GLIBCPP_USE_LONG_LONG */

template<> struct __type_traits {

   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 {

   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 {

   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<_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  struct _Is_integer {

  typedef __false_type _Integral;

};

template<> struct _Is_integer {

  typedef __true_type _Integral;

};

template<> struct _Is_integer {

  typedef __true_type _Integral;

};

template<> struct _Is_integer {

  typedef __true_type _Integral;

};

template<> struct _Is_integer {

  typedef __true_type _Integral;

};

template<> struct _Is_integer {

  typedef __true_type _Integral;

};

template<> struct _Is_integer {

  typedef __true_type _Integral;

};

template<> struct _Is_integer {

  typedef __true_type _Integral;

};

template<> struct _Is_integer {

  typedef __true_type _Integral;

};

template<> struct _Is_integer {

  typedef __true_type _Integral;

};

template<> struct _Is_integer {

  typedef __true_type _Integral;

};

template<> struct _Is_integer {

  typedef __true_type _Integral;

};

#ifdef _GLIBCPP_USE_LONG_LONG

template<> struct _Is_integer {

  typedef __true_type _Integral;

};

template<> struct _Is_integer {

  typedef __true_type _Integral;

};

#endif /* _GLIBCPP_USE_LONG_LONG */

template struct _Is_normal_iterator {

   typedef __false_type _Normal;

};

// Forward declaration hack, should really include this from somewhere.

namespace std {

   template class __normal_iterator;

};

template

struct _Is_normal_iterator< std::__normal_iterator<_Iterator, _Container> > {

   typedef __true_type _Normal;

};

#endif /* _CPP_BITS_TYPE_TRAITS_H */

// Local Variables:

// mode:C++

// End: