diff options
Diffstat (limited to 'stlport/stl/type_traits.h')
-rw-r--r-- | stlport/stl/type_traits.h | 626 |
1 files changed, 0 insertions, 626 deletions
diff --git a/stlport/stl/type_traits.h b/stlport/stl/type_traits.h deleted file mode 100644 index af0923d..0000000 --- a/stlport/stl/type_traits.h +++ /dev/null @@ -1,626 +0,0 @@ -/* - * - * Copyright (c) 1996,1997 - * Silicon Graphics Computer Systems, Inc. - * - * Copyright (c) 1997 - * Moscow Center for SPARC Technology - * - * Copyright (c) 1999 - * Boris Fomitchev - * - * This material is provided "as is", with absolutely no warranty expressed - * or implied. Any use is at your own risk. - * - * Permission to use or copy this software for any purpose is hereby granted - * without fee, provided the above notices are retained on all copies. - * Permission to modify the code and to distribute modified code is granted, - * provided the above notices are retained, and a notice that the code was - * modified is included with the above copyright notice. - * - */ - -#ifndef _STLP_TYPE_TRAITS_H -#define _STLP_TYPE_TRAITS_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 T> void copy(T* source, T* destination, int n, __false_type); -//Copy an array of elements which have trivial copy constructors. Use memcpy. -template <class T> void copy(T* source, T* destination, int n, __true_type); - -//Copy an array of any type by using the most efficient copy mechanism -template <class T> inline void copy(T* source,T* destination,int n) { - copy(source, destination, n, - typename __type_traits<T>::has_trivial_copy_constructor()); -} -*/ - -#ifdef __WATCOMC__ -# include <stl/_cwchar.h> -#endif - -#ifndef _STLP_TYPE_MANIPS_H -# include <stl/type_manips.h> -#endif - -#ifdef _STLP_USE_BOOST_SUPPORT -# include <stl/boost_type_traits.h> -# include <boost/type_traits/add_reference.hpp> -# include <boost/type_traits/add_const.hpp> -#endif /* _STLP_USE_BOOST_SUPPORT */ - -_STLP_BEGIN_NAMESPACE - -#if !defined (_STLP_USE_BOOST_SUPPORT) - -// 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 _IsIntegral -{ typedef __false_type _Ret; }; - -# ifndef _STLP_NO_BOOL -_STLP_TEMPLATE_NULL struct _IsIntegral<bool> -{ typedef __true_type _Ret; }; -# endif /* _STLP_NO_BOOL */ - -_STLP_TEMPLATE_NULL struct _IsIntegral<char> -{ typedef __true_type _Ret; }; - -# ifndef _STLP_NO_SIGNED_BUILTINS -_STLP_TEMPLATE_NULL struct _IsIntegral<signed char> -{ typedef __true_type _Ret; }; -# endif - -_STLP_TEMPLATE_NULL struct _IsIntegral<unsigned char> -{ typedef __true_type _Ret; }; - -# if defined ( _STLP_HAS_WCHAR_T ) && ! defined (_STLP_WCHAR_T_IS_USHORT) -_STLP_TEMPLATE_NULL struct _IsIntegral<wchar_t> -{ typedef __true_type _Ret; }; -# endif /* _STLP_HAS_WCHAR_T */ - -_STLP_TEMPLATE_NULL struct _IsIntegral<short> -{ typedef __true_type _Ret; }; - -_STLP_TEMPLATE_NULL struct _IsIntegral<unsigned short> -{ typedef __true_type _Ret; }; - -_STLP_TEMPLATE_NULL struct _IsIntegral<int> -{ typedef __true_type _Ret; }; - -_STLP_TEMPLATE_NULL struct _IsIntegral<unsigned int> -{ typedef __true_type _Ret; }; - -_STLP_TEMPLATE_NULL struct _IsIntegral<long> -{ typedef __true_type _Ret; }; - -_STLP_TEMPLATE_NULL struct _IsIntegral<unsigned long> -{ typedef __true_type _Ret; }; - -# ifdef _STLP_LONG_LONG -_STLP_TEMPLATE_NULL struct _IsIntegral<_STLP_LONG_LONG> -{ typedef __true_type _Ret; }; - -_STLP_TEMPLATE_NULL struct _IsIntegral<unsigned _STLP_LONG_LONG> -{ typedef __true_type _Ret; }; -# endif /* _STLP_LONG_LONG */ - -template <class _Tp> struct _IsRational -{ typedef __false_type _Ret; }; - -_STLP_TEMPLATE_NULL struct _IsRational<float> -{ typedef __true_type _Ret; }; - -_STLP_TEMPLATE_NULL struct _IsRational<double> -{ typedef __true_type _Ret; }; - -# if !defined ( _STLP_NO_LONG_DOUBLE ) -_STLP_TEMPLATE_NULL struct _IsRational<long double> -{ typedef __true_type _Ret; }; -# endif - -// Forward declarations. -template <class _Tp> struct __type_traits; -template <class _IsPOD> struct __type_traits_aux { - 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; -}; - -_STLP_TEMPLATE_NULL -struct __type_traits_aux<__false_type> { - 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; -}; - -_STLP_TEMPLATE_NULL -struct __type_traits_aux<__true_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; -}; - -template <class _Tp> -struct _IsRef { - typedef __false_type _Ret; -}; - -# if defined (_STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS) -/* - * Boris : simulation technique is used here according to Adobe Open Source License Version 1.0. - * Copyright 2000 Adobe Systems Incorporated and others. All rights reserved. - * Authors: Mat Marcus and Jesse Jones - * The original version of this source code may be found at - * http://opensource.adobe.com. - */ - -struct _PointerShim { - /* - * Since the compiler only allows at most one non-trivial - * implicit conversion we can make use of a shim class to - * be sure that IsPtr below doesn't accept classes with - * implicit pointer conversion operators - */ - _PointerShim(const volatile void*); // no implementation -}; - -// These are the discriminating functions -char _STLP_CALL _IsP(bool, _PointerShim); // no implementation is required -char* _STLP_CALL _IsP(bool, ...); // no implementation is required - -template <class _Tp> -struct _IsPtr { - /* - * This template meta function takes a type T - * and returns true exactly when T is a pointer. - * One can imagine meta-functions discriminating on - * other criteria. - */ - static _Tp& __null_rep(); - enum { _Ptr = (sizeof(_IsP(false,__null_rep())) == sizeof(char)) }; - typedef typename __bool2type<_Ptr>::_Ret _Ret; - -}; - -// we make general case dependant on the fact the type is actually a pointer. -template <class _Tp> -struct __type_traits : __type_traits_aux<typename _IsPtr<_Tp>::_Ret> {}; - -# else /* _STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS */ - -template <class _Tp> struct _IsPtr { - typedef __false_type _Ret; -}; - -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. */ -# if !defined (_STLP_HAS_TYPE_TRAITS_INTRINSICS) - 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; -# else - typedef typename __bool2type<_STLP_HAS_TRIVIAL_CONSTRUCTOR(_Tp)>::_Ret has_trivial_default_constructor; - typedef typename __bool2type<_STLP_HAS_TRIVIAL_COPY(_Tp)>::_Ret has_trivial_copy_constructor; - typedef typename __bool2type<_STLP_HAS_TRIVIAL_ASSIGN(_Tp)>::_Ret has_trivial_assignment_operator; - typedef typename __bool2type<_STLP_HAS_TRIVIAL_DESTRUCTOR(_Tp)>::_Ret has_trivial_destructor; - typedef typename __bool2type<_STLP_IS_POD(_Tp)>::_Ret is_POD_type; -# endif -}; - -# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) -template <class _Tp> struct _IsPtr<_Tp*> -{ typedef __true_type _Ret; }; -template <class _Tp> struct _IsRef<_Tp&> -{ typedef __true_type _Ret; }; - -template <class _Tp> struct __type_traits<_Tp*> : __type_traits_aux<__true_type> -{}; -# endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */ - -# endif /* _STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS */ - -// Provide some specializations. This is harmless for compilers that -// have built-in __types_traits support, and essential for compilers -// that don't. -# if !defined (_STLP_QUALIFIED_SPECIALIZATION_BUG) -# define _STLP_DEFINE_TYPE_TRAITS_FOR(Type) \ -_STLP_TEMPLATE_NULL struct __type_traits< Type > : __type_traits_aux<__true_type> {}; \ -_STLP_TEMPLATE_NULL struct __type_traits< const Type > : __type_traits_aux<__true_type> {}; \ -_STLP_TEMPLATE_NULL struct __type_traits< volatile Type > : __type_traits_aux<__true_type> {}; \ -_STLP_TEMPLATE_NULL struct __type_traits< const volatile Type > : __type_traits_aux<__true_type> {} -# else -# define _STLP_DEFINE_TYPE_TRAITS_FOR(Type) \ -_STLP_TEMPLATE_NULL struct __type_traits< Type > : __type_traits_aux<__true_type> {}; -# endif - -# ifndef _STLP_NO_BOOL -_STLP_DEFINE_TYPE_TRAITS_FOR(bool); -# endif /* _STLP_NO_BOOL */ -_STLP_DEFINE_TYPE_TRAITS_FOR(char); -# ifndef _STLP_NO_SIGNED_BUILTINS -_STLP_DEFINE_TYPE_TRAITS_FOR(signed char); -# endif -_STLP_DEFINE_TYPE_TRAITS_FOR(unsigned char); -# if defined ( _STLP_HAS_WCHAR_T ) && ! defined (_STLP_WCHAR_T_IS_USHORT) -_STLP_DEFINE_TYPE_TRAITS_FOR(wchar_t); -# endif /* _STLP_HAS_WCHAR_T */ - -_STLP_DEFINE_TYPE_TRAITS_FOR(short); -_STLP_DEFINE_TYPE_TRAITS_FOR(unsigned short); -_STLP_DEFINE_TYPE_TRAITS_FOR(int); -_STLP_DEFINE_TYPE_TRAITS_FOR(unsigned int); -_STLP_DEFINE_TYPE_TRAITS_FOR(long); -_STLP_DEFINE_TYPE_TRAITS_FOR(unsigned long); - -# ifdef _STLP_LONG_LONG -_STLP_DEFINE_TYPE_TRAITS_FOR(_STLP_LONG_LONG); -_STLP_DEFINE_TYPE_TRAITS_FOR(unsigned _STLP_LONG_LONG); -# endif /* _STLP_LONG_LONG */ - -_STLP_DEFINE_TYPE_TRAITS_FOR(float); -_STLP_DEFINE_TYPE_TRAITS_FOR(double); - -# if !defined ( _STLP_NO_LONG_DOUBLE ) -_STLP_DEFINE_TYPE_TRAITS_FOR(long double); -# endif - -# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) -template <class _ArePtrs, class _Src, class _Dst> -struct _IsCVConvertibleIf -{ typedef typename _IsCVConvertible<_Src, _Dst>::_Ret _Ret; }; - -template <class _Src, class _Dst> -struct _IsCVConvertibleIf<__false_type, _Src, _Dst> -{ typedef __false_type _Ret; }; -# else -# if defined (_STLP_MEMBER_TEMPLATE_CLASSES) -template <class _ArePtrs> -struct _IsCVConvertibleIfAux { - template <class _Src, class _Dst> - struct _In - { typedef typename _IsCVConvertible<_Src, _Dst>::_Ret _Ret; }; -}; - -_STLP_TEMPLATE_NULL -struct _IsCVConvertibleIfAux<__false_type> { - template <class _Src, class _Dst> - struct _In - { typedef __false_type _Ret; }; -}; - -template <class _ArePtrs, class _Src, class _Dst> -struct _IsCVConvertibleIf { - typedef typename _IsCVConvertibleIfAux<_ArePtrs>::_STLP_TEMPLATE _In<_Src, _Dst>::_Ret _Ret; -}; -# else -/* default behavior: we prefer to miss an optimization rather than taking the risk of - * a compilation error if playing with types with exotic memory alignment. - */ -template <class _ArePtrs, class _Src, class _Dst> -struct _IsCVConvertibleIf -{ typedef __false_type _Ret; }; -# endif -# endif - -template <class _Src, class _Dst> -struct _TrivialNativeTypeCopy { - typedef typename _IsPtr<_Src>::_Ret _Ptr1; - typedef typename _IsPtr<_Dst>::_Ret _Ptr2; - typedef typename _Land2<_Ptr1, _Ptr2>::_Ret _BothPtrs; - typedef typename _IsCVConvertibleIf<_BothPtrs, _Src, _Dst>::_Ret _Convertible; - typedef typename _Land2<_BothPtrs, _Convertible>::_Ret _Trivial1; - - typedef typename __bool2type<(sizeof(_Src) == sizeof(_Dst))>::_Ret _SameSize; - -#if !defined (__BORLANDC__) || (__BORLANDC__ < 0x564) - typedef typename _IsIntegral<_Src>::_Ret _Int1; -#else - typedef typename _UnQual<_Src>::_Type _UnQuSrc; - typedef typename _IsIntegral<_UnQuSrc>::_Ret _Int1; -#endif - typedef typename _IsIntegral<_Dst>::_Ret _Int2; - typedef typename _Land2<_Int1, _Int2>::_Ret _BothInts; - - typedef typename _IsRational<_Src>::_Ret _Rat1; - typedef typename _IsRational<_Dst>::_Ret _Rat2; - typedef typename _Land2<_Rat1, _Rat2>::_Ret _BothRats; - - typedef typename _Lor2<_BothInts, _BothRats>::_Ret _BothNatives; -#if !defined (__BORLANDC__) || (__BORLANDC__ >= 0x564) - typedef typename _Land2<_BothNatives, _SameSize>::_Ret _Trivial2; -#else - typedef typename _IsUnQual<_Dst>::_Ret _UnQualDst; - typedef typename _Land3<_BothNatives, _SameSize, _UnQualDst>::_Ret _Trivial2; -#endif - typedef typename _Lor2<_Trivial1, _Trivial2>::_Ret _Ret; -}; - -template <class _Src, class _Dst> -struct _TrivialCopy { - typedef typename _TrivialNativeTypeCopy<_Src, _Dst>::_Ret _NativeRet; -# if !defined (__BORLANDC__) || (__BORLANDC__ != 0x560) - typedef typename __type_traits<_Src>::has_trivial_assignment_operator _Tr1; -# else - typedef typename _UnConstPtr<_Src*>::_Type _UnConstSrc; - typedef typename __type_traits<_UnConstSrc>::has_trivial_assignment_operator _Tr1; -# endif - typedef typename _AreCopyable<_Src, _Dst>::_Ret _Tr2; - typedef typename _Land2<_Tr1, _Tr2>::_Ret _UserRet; - typedef typename _Lor2<_NativeRet, _UserRet>::_Ret _Ret; - static _Ret _Answer() { return _Ret(); } -}; - -template <class _Src, class _Dst> -struct _TrivialUCopy { - typedef typename _TrivialNativeTypeCopy<_Src, _Dst>::_Ret _NativeRet; -# if !defined (__BORLANDC__) || (__BORLANDC__ != 0x560) - typedef typename __type_traits<_Src>::has_trivial_copy_constructor _Tr1; -# else - typedef typename _UnConstPtr<_Src*>::_Type _UnConstSrc; - typedef typename __type_traits<_UnConstSrc>::has_trivial_copy_constructor _Tr1; -# endif - typedef typename _AreCopyable<_Src, _Dst>::_Ret _Tr2; - typedef typename _Land2<_Tr1, _Tr2>::_Ret _UserRet; - typedef typename _Lor2<_NativeRet, _UserRet>::_Ret _Ret; - static _Ret _Answer() { return _Ret(); } -}; - -template <class _Tp> -struct _DefaultZeroValue { - typedef typename _IsIntegral<_Tp>::_Ret _Tr1; - typedef typename _IsRational<_Tp>::_Ret _Tr2; - typedef typename _IsPtr<_Tp>::_Ret _Tr3; - typedef typename _Lor3<_Tr1, _Tr2, _Tr3>::_Ret _Ret; -}; - -template <class _Tp> -struct _TrivialInit { -# if !defined (__BORLANDC__) || (__BORLANDC__ != 0x560) - typedef typename __type_traits<_Tp>::has_trivial_default_constructor _Tr1; -# else - typedef typename _UnConstPtr<_Tp*>::_Type _Tp1; - typedef typename __type_traits<_Tp1>::has_trivial_copy_constructor _Tr1; -# endif - typedef typename _DefaultZeroValue<_Tp>::_Ret _Tr2; - typedef typename _Not<_Tr2>::_Ret _Tr3; - typedef typename _Land2<_Tr1, _Tr3>::_Ret _Ret; - static _Ret _Answer() { return _Ret(); } -}; - -#endif /* !_STLP_USE_BOOST_SUPPORT */ - -template <class _Tp> -struct _IsPtrType { - typedef typename _IsPtr<_Tp>::_Ret _Type; - static _Type _Ret() { return _Type(); } -}; - -template <class _Tp> -struct _IsRefType { - typedef typename _IsRef<_Tp>::_Ret _Type; - static _Type _Ret() { return _Type();} -}; - -template <class _Tp> -struct __call_traits { -#if defined (_STLP_USE_BOOST_SUPPORT) && !defined (_STLP_NO_EXTENSIONS) - typedef typename __select< ::boost::is_reference<_Tp>::value, - typename ::boost::add_const<_Tp>::type, - typename ::boost::add_reference< typename ::boost::add_const<_Tp>::type >::type>::_Ret const_param_type; - typedef typename __select< ::boost::is_reference<_Tp>::value, - typename ::boost::remove_const<_Tp>::type, - typename ::boost::add_reference<_Tp>::type>::_Ret param_type; -#else - typedef const _Tp& const_param_type; - typedef _Tp& param_type; -#endif -}; - -#if !defined (_STLP_USE_BOOST_SUPPORT) && !defined (_STLP_NO_EXTENSIONS) && defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) -template <class _Tp> -struct __call_traits<_Tp&> { - typedef _Tp& param_type; - typedef const _Tp& const_param_type; -}; -template <class _Tp> -struct __call_traits<const _Tp&> { - typedef _Tp& param_type; - typedef const _Tp& const_param_type; -}; -#endif - -template <class _Tp1, class _Tp2> -struct _BothPtrType { - typedef typename _IsPtr<_Tp1>::_Ret _IsPtr1; - typedef typename _IsPtr<_Tp2>::_Ret _IsPtr2; - - typedef typename _Land2<_IsPtr1, _IsPtr2>::_Ret _Ret; - static _Ret _Answer() { return _Ret(); } -}; - -template <class _Tp1, class _Tp2, class _IsRef1, class _IsRef2> -struct _OKToSwap { - typedef typename _AreSameTypes<_Tp1, _Tp2>::_Ret _Same; - typedef typename _Land3<_Same, _IsRef1, _IsRef2>::_Ret _Type; - static _Type _Answer() { return _Type(); } -}; - -template <class _Tp1, class _Tp2, class _IsRef1, class _IsRef2> -inline _OKToSwap<_Tp1, _Tp2, _IsRef1, _IsRef2> -_IsOKToSwap(_Tp1*, _Tp2*, const _IsRef1&, const _IsRef2&) -{ return _OKToSwap<_Tp1, _Tp2, _IsRef1, _IsRef2>(); } - -template <class _Src, class _Dst> -inline _TrivialCopy<_Src, _Dst> _UseTrivialCopy(_Src*, _Dst*) -{ return _TrivialCopy<_Src, _Dst>(); } - -template <class _Src, class _Dst> -inline _TrivialUCopy<_Src, _Dst> _UseTrivialUCopy(_Src*, _Dst*) -{ return _TrivialUCopy<_Src, _Dst>(); } - -#if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) || defined (__BORLANDC__) || \ - defined (__DMC__) -struct _NegativeAnswer { - typedef __false_type _Ret; - static _Ret _Answer() { return _Ret(); } -}; - -template <class _Src, class _Dst> -inline _NegativeAnswer _UseTrivialCopy(_Src*, const _Dst*) -{ return _NegativeAnswer(); } - -template <class _Src, class _Dst> -inline _NegativeAnswer _UseTrivialCopy(_Src*, volatile _Dst*) -{ return _NegativeAnswer(); } - -template <class _Src, class _Dst> -inline _NegativeAnswer _UseTrivialCopy(_Src*, const volatile _Dst*) -{ return _NegativeAnswer(); } - -template <class _Src, class _Dst> -inline _NegativeAnswer _UseTrivialUCopy(_Src*, const _Dst*) -{ return _NegativeAnswer(); } - -template <class _Src, class _Dst> -inline _NegativeAnswer _UseTrivialUCopy(_Src*, volatile _Dst*) -{ return _NegativeAnswer(); } - -template <class _Src, class _Dst> -inline _NegativeAnswer _UseTrivialUCopy(_Src*, const volatile _Dst*) -{ return _NegativeAnswer(); } -#endif - -template <class _Tp> -inline _TrivialInit<_Tp> _UseTrivialInit(_Tp*) -{ return _TrivialInit<_Tp>(); } - -template <class _Tp> -struct _IsPOD { - typedef typename __type_traits<_Tp>::is_POD_type _Type; - static _Type _Answer() { return _Type(); } -}; - -template <class _Tp> -inline _IsPOD<_Tp> _Is_POD(_Tp*) -{ return _IsPOD<_Tp>(); } - -template <class _Tp> -struct _DefaultZeroValueQuestion { - typedef typename _DefaultZeroValue<_Tp>::_Ret _Ret; - static _Ret _Answer() { return _Ret(); } -}; - -template <class _Tp> -inline _DefaultZeroValueQuestion<_Tp> _HasDefaultZeroValue(_Tp*) -{ return _DefaultZeroValueQuestion<_Tp>(); } - -/* - * Base class used: - * - to simulate partial template specialization - * - to simulate partial function ordering - * - to recognize STLport class from user specialized one - */ -template <class _Tp> -struct __stlport_class -{ typedef _Tp _Type; }; - -template <class _Tp> -struct _IsSTLportClass { - typedef typename _IsConvertible<_Tp, __stlport_class<_Tp> >::_Ret _Ret; -#if defined (__BORLANDC__) - enum { _Is = _IsConvertible<_Tp, __stlport_class<_Tp> >::value }; -#endif -}; - -#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) -template <class _Tp> -struct _SwapImplemented { - typedef typename _IsSTLportClass<_Tp>::_Ret _Ret; -# if defined (__BORLANDC__) - enum { _Is = _IsSTLportClass<_Tp>::_Is }; -# endif -}; -#endif - -template <class _Tp> -class _TpWithState : private _Tp { - _TpWithState(); - int _state; -}; - -/* This is an internal helper struct used to guess if we are working - * on a stateless class. It can only be instanciated with a class type. */ -template <class _Tp> -struct _IsStateless { - enum { _Is = sizeof(_TpWithState<_Tp>) == sizeof(int) }; - typedef typename __bool2type<_Is>::_Ret _Ret; -}; - -_STLP_END_NAMESPACE - -#ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION -# if defined (__BORLANDC__) || \ - defined (__SUNPRO_CC) || \ - (defined (__MWERKS__) && (__MWERKS__ <= 0x2303)) || \ - (defined (__sgi) && defined (_COMPILER_VERSION)) || \ - defined (__DMC__) -# define _STLP_IS_POD_ITER(_It, _Tp) __type_traits< typename iterator_traits< _Tp >::value_type >::is_POD_type() -# else -# define _STLP_IS_POD_ITER(_It, _Tp) typename __type_traits< typename iterator_traits< _Tp >::value_type >::is_POD_type() -# endif -#else -# define _STLP_IS_POD_ITER(_It, _Tp) _Is_POD( _STLP_VALUE_TYPE( _It, _Tp ) )._Answer() -#endif - -#endif /* _STLP_TYPE_TRAITS_H */ - -// Local Variables: -// mode:C++ -// End: |