type_traits.h

粗糙集应用软件

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;
};

# if 0 /* not used */

// provide a mechanism for partial specialization of various
// type_traits. No reason for __true_dominate for now.

template <class T1, class T2>
struct __false_dominate {
    typedef __false_type resulting_type;
};

__STL_TEMPLATE_NULL 
struct __false_dominate<__true_type, __true_type> {
    typedef __true_type  resulting_type;
};

// a type_traits for two types composition (for pairs)
template <class T1, class T2>
struct __type_traits_compose {
    typedef __type_traits<T1> type1;
    typedef __type_traits<T2> type2;
    typedef typename __false_dominate<typename type1::has_trivial_default_constructor,
                          typename type2::has_trivial_default_constructor>::resulting_type 
            has_trivial_default_constructor;
    typedef typename __false_dominate<typename type1::has_trivial_copy_constructor,
                          typename type2::has_trivial_copy_constructor>::resulting_type 
            has_trivial_copy_constructor;
    typedef typename __false_dominate<typename type1::has_trivial_assignment_operator,
                          typename type2::has_trivial_assignment_operator>::resulting_type 
            has_trivial_assignment_operator;
    typedef typename __false_dominate<typename type1::has_trivial_destructor,
                             typename type2::has_trivial_destructor>::resulting_type 
            has_trivial_destructor;
    typedef typename __false_dominate<typename type1::is_POD_type,
                             typename type2::is_POD_type>::resulting_type 
            is_POD_type;
};
# endif

#  define __STL_DEFINE_ARROW_OPERATOR  pointer operator->() const { return &(operator*()); }

#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */

// Important pointers specializations

# define __STL_TYPE_TRAITS_POD_SPECIALIZE(_Type) \
__STL_TEMPLATE_NULL \
struct __type_traits<_Type> { \
   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 is a workaround for arrow operator problems
#  if defined  ( __SGI_STL_NO_ARROW_OPERATOR ) 

#   if defined (__STL_NO_PROXY_ARROW_OPERATOR)

// User wants to disable proxy -> operators
#    define __STL_DEFINE_ARROW_OPERATOR
#    define __STL_ARROW_SPECIALIZE_WITH_PTRS(_Tp)

#   else

// Proxy -> operator workaround for compilers that produce
// type checking errors on unused ->() operators

template <class _Ref, class _Ptr>
struct __arrow_op_dispatch {
  _Ptr _M_ptr;
  __arrow_op_dispatch(_Ref __r) : _M_ptr(&__r) {}
  _Ptr operator ->() const { return _M_ptr; }
};

struct __arrow_op_dummy { int _M_data ; };

#  define __STL_ARROW_SPECIALIZE(_Tp)  \
__STL_TEMPLATE_NULL struct __arrow_op_dispatch<_Tp&, _Tp*> { \
  __arrow_op_dispatch(_Tp&) {} \
  __arrow_op_dummy operator ->() const { return __arrow_op_dummy(); } \
};

#  define __STL_ARROW_SPECIALIZE_WITH_PTRS(_Tp) \
__STL_ARROW_SPECIALIZE(_Tp) \
__STL_ARROW_SPECIALIZE(const _Tp) \
__STL_ARROW_SPECIALIZE(_Tp*) \
__STL_ARROW_SPECIALIZE(const _Tp*) \
__STL_ARROW_SPECIALIZE(_Tp**) \
__STL_ARROW_SPECIALIZE(const _Tp**) \
__STL_ARROW_SPECIALIZE(_Tp* const *) \
__STL_ARROW_SPECIALIZE(_Tp***) \
__STL_ARROW_SPECIALIZE(const _Tp***)

#  define __STL_DEFINE_ARROW_OPERATOR __arrow_op_dispatch<reference, pointer> operator->() const \
 { return __arrow_op_dispatch<reference, pointer>(this->operator*()); }

#  endif /* __STL_NO_PROXY_ARROW_OPERATOR */
# else

#  define __STL_ARROW_SPECIALIZE_WITH_PTRS(_Tp)
#  define __STL_DEFINE_ARROW_OPERATOR  pointer operator->() const { return &(operator*()); }

# endif /* __SGI_STL_NO_ARROW_OPERATOR */

# define __STL_TYPE_TRAITS_POD_SPECIALIZE_V(_Type) \
__STL_TYPE_TRAITS_POD_SPECIALIZE(_Type*) \
__STL_TYPE_TRAITS_POD_SPECIALIZE(const _Type*) \
__STL_TYPE_TRAITS_POD_SPECIALIZE(_Type**) \
__STL_TYPE_TRAITS_POD_SPECIALIZE(_Type* const *) \
__STL_TYPE_TRAITS_POD_SPECIALIZE(const _Type**) \
__STL_TYPE_TRAITS_POD_SPECIALIZE(_Type***) \
__STL_TYPE_TRAITS_POD_SPECIALIZE(const _Type***) \

# define __STL_TYPE_TRAITS_POD_PTRS_SPECIALIZE(_Type) \
__STL_TYPE_TRAITS_POD_SPECIALIZE_V(_Type) \
__STL_ARROW_SPECIALIZE_WITH_PTRS(_Type)

#  if !defined ( __STL_NO_BOOL )
__STL_TYPE_TRAITS_POD_PTRS_SPECIALIZE( bool )
#  endif
__STL_TYPE_TRAITS_POD_SPECIALIZE_V(void)
  __STL_ARROW_SPECIALIZE_WITH_PTRS(void*)
  __STL_ARROW_SPECIALIZE_WITH_PTRS(void* const)
# ifndef __STL_NO_SIGNED_BUILTINS
  __STL_TYPE_TRAITS_POD_PTRS_SPECIALIZE( signed char )
# endif
  __STL_TYPE_TRAITS_POD_PTRS_SPECIALIZE( char )
  __STL_TYPE_TRAITS_POD_PTRS_SPECIALIZE( unsigned char )
  __STL_TYPE_TRAITS_POD_PTRS_SPECIALIZE( short )
  __STL_TYPE_TRAITS_POD_PTRS_SPECIALIZE( unsigned short )
  __STL_TYPE_TRAITS_POD_PTRS_SPECIALIZE( int )
  __STL_TYPE_TRAITS_POD_PTRS_SPECIALIZE( unsigned int )
  __STL_TYPE_TRAITS_POD_PTRS_SPECIALIZE( long )
  __STL_TYPE_TRAITS_POD_PTRS_SPECIALIZE( unsigned long )
  __STL_TYPE_TRAITS_POD_PTRS_SPECIALIZE( float )
  __STL_TYPE_TRAITS_POD_PTRS_SPECIALIZE( double )
#  if !defined ( __STL_NO_LONG_DOUBLE )
  __STL_TYPE_TRAITS_POD_PTRS_SPECIALIZE( long double )
#  endif
#  if defined ( __STL_LONG_LONG)
  __STL_TYPE_TRAITS_POD_PTRS_SPECIALIZE( long long )
#  endif
#if defined ( __STL_HAS_WCHAR_T ) && ! defined (__STL_WCHAR_T_IS_USHORT)
  __STL_TYPE_TRAITS_POD_PTRS_SPECIALIZE( wchar_t )
#  endif

# undef __STL_ARROW_SPECIALIZE
# undef __STL_ARROW_SPECIALIZE_WITH_PTRS
# undef __STL_TYPE_TRAITS_POD_PTRS_SPECIALIZE
  // # undef __STL_TYPE_TRAITS_POD_SPECIALIZE
# undef __STL_TYPE_TRAITS_POD_SPECIALIZE_V

#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

// 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;
};

#ifndef __STL_NO_BOOL

__STL_TEMPLATE_NULL struct _Is_integer<bool> {
  typedef __true_type _Integral;
};

#endif /* __STL_NO_BOOL */

__STL_TEMPLATE_NULL struct _Is_integer<char> {
  typedef __true_type _Integral;
};

#ifndef __STL_NO_SIGNED_BUILTINS

__STL_TEMPLATE_NULL struct _Is_integer<signed char> {
  typedef __true_type _Integral;
};
#endif

__STL_TEMPLATE_NULL struct _Is_integer<unsigned char> {
  typedef __true_type _Integral;
};

#if defined ( __STL_HAS_WCHAR_T ) && ! defined (__STL_WCHAR_T_IS_USHORT)

__STL_TEMPLATE_NULL struct _Is_integer<wchar_t> {
  typedef __true_type _Integral;
};

#endif /* __STL_HAS_WCHAR_T */

__STL_TEMPLATE_NULL struct _Is_integer<short> {
  typedef __true_type _Integral;
};

__STL_TEMPLATE_NULL struct _Is_integer<unsigned short> {
  typedef __true_type _Integral;
};

__STL_TEMPLATE_NULL struct _Is_integer<int> {
  typedef __true_type _Integral;
};

__STL_TEMPLATE_NULL struct _Is_integer<unsigned int> {
  typedef __true_type _Integral;
};

__STL_TEMPLATE_NULL struct _Is_integer<long> {
  typedef __true_type _Integral;
};

__STL_TEMPLATE_NULL struct _Is_integer<unsigned long> {
  typedef __true_type _Integral;
};

#ifdef __STL_LONG_LONG

__STL_TEMPLATE_NULL struct _Is_integer<long long> {
  typedef __true_type _Integral;
};

__STL_TEMPLATE_NULL struct _Is_integer<unsigned long long> {
  typedef __true_type _Integral;
};

#endif /* __STL_LONG_LONG */

#endif /* __TYPE_TRAITS_H */

// Local Variables:
// mode:C++
// End: