1 /* 2 * 3 * Copyright (c) 2003 4 * Francois Dumont 5 * 6 * This material is provided "as is", with absolutely no warranty expressed 7 * or implied. Any use is at your own risk. 8 * 9 * Permission to use or copy this software for any purpose is hereby granted 10 * without fee, provided the above notices are retained on all copies. 11 * Permission to modify the code and to distribute modified code is granted, 12 * provided the above notices are retained, and a notice that the code was 13 * modified is included with the above copyright notice. 14 * 15 */ 16 17 18 #ifndef _STLP_TYPE_MANIPS_H 19 #define _STLP_TYPE_MANIPS_H 20 21 _STLP_BEGIN_NAMESPACE 22 23 struct __true_type {}; 24 struct __false_type {}; 25 26 #if defined (_STLP_USE_NAMESPACES) && !defined (_STLP_DONT_USE_PRIV_NAMESPACE) 27 _STLP_MOVE_TO_PRIV_NAMESPACE 28 using _STLP_STD::__true_type; 29 using _STLP_STD::__false_type; 30 _STLP_MOVE_TO_STD_NAMESPACE 31 #endif 32 33 //bool to type 34 template <int _Is> 35 struct __bool2type 36 { typedef __true_type _Ret; }; 37 38 _STLP_TEMPLATE_NULL 39 struct __bool2type<1> { typedef __true_type _Ret; }; 40 41 _STLP_TEMPLATE_NULL 42 struct __bool2type<0> { typedef __false_type _Ret; }; 43 44 //type to bool 45 template <class __bool_type> 46 struct __type2bool { enum {_Ret = 1}; }; 47 48 _STLP_TEMPLATE_NULL 49 struct __type2bool<__true_type> { enum {_Ret = 1}; }; 50 51 _STLP_TEMPLATE_NULL 52 struct __type2bool<__false_type> { enum {_Ret = 0}; }; 53 54 //Negation 55 template <class _BoolType> 56 struct _Not { typedef __false_type _Ret; }; 57 58 _STLP_TEMPLATE_NULL 59 struct _Not<__false_type> { typedef __true_type _Ret; }; 60 61 // logical and of 2 predicated 62 template <class _P1, class _P2> 63 struct _Land2 { typedef __false_type _Ret; }; 64 65 _STLP_TEMPLATE_NULL 66 struct _Land2<__true_type, __true_type> { typedef __true_type _Ret; }; 67 68 // logical and of 3 predicated 69 template <class _P1, class _P2, class _P3> 70 struct _Land3 { typedef __false_type _Ret; }; 71 72 _STLP_TEMPLATE_NULL 73 struct _Land3<__true_type, __true_type, __true_type> { typedef __true_type _Ret; }; 74 75 //logical or of 2 predicated 76 template <class _P1, class _P2> 77 struct _Lor2 { typedef __true_type _Ret; }; 78 79 _STLP_TEMPLATE_NULL 80 struct _Lor2<__false_type, __false_type> { typedef __false_type _Ret; }; 81 82 // logical or of 3 predicated 83 template <class _P1, class _P2, class _P3> 84 struct _Lor3 { typedef __true_type _Ret; }; 85 86 _STLP_TEMPLATE_NULL 87 struct _Lor3<__false_type, __false_type, __false_type> { typedef __false_type _Ret; }; 88 89 //////////////////////////////////////////////////////////////////////////////// 90 // class template __select 91 // Selects one of two types based upon a boolean constant 92 // Invocation: __select<_Cond, T, U>::Result 93 // where: 94 // flag is a compile-time boolean constant 95 // T and U are types 96 // Result evaluates to T if flag is true, and to U otherwise. 97 //////////////////////////////////////////////////////////////////////////////// 98 // BEWARE: If the compiler do not support partial template specialization or nested template 99 //classes the default behavior of the __select is to consider the condition as false and so return 100 //the second template type!! 101 102 #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) 103 # if defined (__BORLANDC__) 104 template <class _CondT, class _Tp1, class _Tp2> 105 struct __selectT { typedef _Tp1 _Ret; }; 106 107 template <class _Tp1, class _Tp2> 108 struct __selectT<__false_type, _Tp1, _Tp2> { typedef _Tp2 _Ret; }; 109 # endif 110 111 # if !defined (__BORLANDC__) || (__BORLANDC__ >= 0x590) 112 template <bool _Cond, class _Tp1, class _Tp2> 113 struct __select { typedef _Tp1 _Ret; }; 114 115 template <class _Tp1, class _Tp2> 116 struct __select<false, _Tp1, _Tp2> { typedef _Tp2 _Ret; }; 117 # else 118 template <bool _Cond, class _Tp1, class _Tp2> 119 struct __select 120 { typedef __selectT<typename __bool2type<_Cond>::_Ret, _Tp1, _Tp2>::_Ret _Ret; }; 121 # endif 122 123 #else 124 125 # if defined (_STLP_MEMBER_TEMPLATE_CLASSES) 126 template <int _Cond> 127 struct __select_aux { 128 template <class _Tp1, class _Tp2> 129 struct _In { 130 typedef _Tp1 _Ret; 131 }; 132 }; 133 134 _STLP_TEMPLATE_NULL 135 struct __select_aux<0> { 136 template <class _Tp1, class _Tp2> 137 struct _In { 138 typedef _Tp2 _Ret; 139 }; 140 }; 141 142 template <int _Cond, class _Tp1, class _Tp2> 143 struct __select { 144 typedef typename __select_aux<_Cond>::_STLP_TEMPLATE _In<_Tp1, _Tp2>::_Ret _Ret; 145 }; 146 # else /* _STLP_MEMBER_TEMPLATE_CLASSES */ 147 //default behavior 148 template <int _Cond, class _Tp1, class _Tp2> 149 struct __select { 150 typedef _Tp2 _Ret; 151 }; 152 # endif /* _STLP_MEMBER_TEMPLATE_CLASSES */ 153 154 #endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */ 155 156 /* Rather than introducing a new macro for the following constrution we use 157 * an existing one (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS) that 158 * is used for a similar feature. 159 */ 160 #if !defined (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS) && \ 161 (!defined (__GNUC__) || (__GNUC__ > 2)) 162 // Helper struct that will forbid volatile qualified types: 163 # if !defined (__BORLANDC__) 164 struct _NoVolatilePointerShim { _NoVolatilePointerShim(const void*); }; 165 template <class _Tp> 166 char _STLP_CALL _IsCopyableFun(bool, _NoVolatilePointerShim, _Tp const*, _Tp*); // no implementation is required 167 char* _STLP_CALL _IsCopyableFun(bool, ...); // no implementation is required 168 169 template <class _Src, class _Dst> 170 struct _Copyable { 171 static _Src* __null_src(); 172 static _Dst* __null_dst(); 173 enum { _Ret = (sizeof(_IsCopyableFun(false, __null_src(), __null_src(), __null_dst())) == sizeof(char)) }; 174 typedef typename __bool2type<_Ret>::_Ret _RetT; 175 }; 176 # else 177 template <class _Tp1, class _Tp2> struct _AreSameTypes; 178 template <class _Tp> struct _IsUnQual; 179 template <class _Src, class _Dst> 180 struct _Copyable { 181 typedef typename _AreSameTypes<_Src, _Dst>::_Ret _Tr1; 182 typedef typename _IsUnQual<_Dst>::_Ret _Tr2; 183 typedef typename _Land2<_Tr1, _Tr2>::_Ret _RetT; 184 enum { _Ret = __type2bool<_RetT>::_Ret }; 185 }; 186 # endif 187 #else 188 template <class _Src, class _Dst> 189 struct _Copyable { 190 enum { _Ret = 0 }; 191 typedef __false_type _RetT; 192 }; 193 #endif 194 195 /* 196 * The following struct will tell you if 2 types are the same and if copying memory 197 * from the _Src type to the _Dst type is right considering qualifiers. If _Src and 198 * _Dst types are the same unqualified types _Ret will be false if: 199 * - any of the type has the volatile qualifier 200 * - _Dst is const qualified 201 */ 202 template <class _Src, class _Dst> 203 struct _AreCopyable { 204 enum { _Same = _Copyable<_Src, _Dst>::_Ret }; 205 typedef typename _Copyable<_Src, _Dst>::_RetT _Ret; 206 }; 207 208 template <class _Tp1, class _Tp2> 209 struct _AreSameTypes { 210 enum { _Same = 0 }; 211 typedef __false_type _Ret; 212 }; 213 214 #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) 215 template <class _Tp> 216 struct _AreSameTypes<_Tp, _Tp> { 217 enum { _Same = 1 }; 218 typedef __true_type _Ret; 219 }; 220 #endif 221 222 #if !defined (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS) 223 template <class _Src, class _Dst> 224 struct _ConversionHelper { 225 static char _Test(bool, _Dst); 226 static char* _Test(bool, ...); 227 static _Src _MakeSource(); 228 }; 229 230 template <class _Src, class _Dst> 231 struct _IsConvertible { 232 typedef _ConversionHelper<_Src*, const volatile _Dst*> _H; 233 enum { value = (sizeof(char) == sizeof(_H::_Test(false, _H::_MakeSource()))) }; 234 typedef typename __bool2type<value>::_Ret _Ret; 235 }; 236 237 # if defined (__BORLANDC__) 238 # if (__BORLANDC__ < 0x590) 239 template<class _Tp> 240 struct _UnConstPtr { typedef _Tp _Type; }; 241 242 template<class _Tp> 243 struct _UnConstPtr<_Tp*> { typedef _Tp _Type; }; 244 245 template<class _Tp> 246 struct _UnConstPtr<const _Tp*> { typedef _Tp _Type; }; 247 # endif 248 249 # if !defined (_STLP_QUALIFIED_SPECIALIZATION_BUG) 250 template <class _Tp> 251 struct _IsConst { typedef __false_type _Ret; }; 252 # else 253 template <class _Tp> 254 struct _IsConst { typedef _AreSameTypes<_Tp, const _Tp>::_Ret _Ret; }; 255 # endif 256 257 # if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_QUALIFIED_SPECIALIZATION_BUG) 258 template <class _Tp> 259 struct _IsConst <const _Tp> { typedef __true_type _Ret; }; 260 # endif 261 262 # if (__BORLANDC__ < 0x590) 263 template<class _Tp> 264 struct _IsConst<_Tp*> { typedef _AreSameTypes<_Tp*, const _Tp*>::_Ret _Ret; }; 265 # endif 266 template <class _Tp> 267 struct _IsVolatile { typedef _AreSameTypes<_Tp, volatile _Tp>::_Ret _Ret; }; 268 269 template<class _Tp> 270 struct _IsUnQual { 271 typedef _IsConst<_Tp>::_Ret _Tr1; 272 typedef _IsVolatile<_Tp>::_Ret _Tr2; 273 typedef _Not<_Tr1>::_Ret _NotCon; 274 typedef _Not<_Tr2>::_Ret _NotVol; 275 typedef _Land2<_NotCon, _NotVol>::_Ret _Ret; 276 }; 277 278 # if !defined (_STLP_QUALIFIED_SPECIALIZATION_BUG) 279 template <class _Tp> struct _UnQual { typedef _Tp _Type; }; 280 template <class _Tp> struct _UnQual<const _Tp> { typedef _Tp _Type; }; 281 template <class _Tp> struct _UnQual<volatile _Tp> { typedef _Tp _Type; }; 282 template <class _Tp> struct _UnQual<const volatile _Tp> { typedef _Tp _Type; }; 283 # endif 284 # endif 285 286 /* This struct is intended to say if a pointer can be convertible to an other 287 * taking into account cv qualifications. It shouldn't be instanciated with 288 * something else than pointer type as it uses pass by value parameter that 289 * results in compilation error when parameter type has a special memory 290 * alignment 291 */ 292 template <class _Src, class _Dst> 293 struct _IsCVConvertible { 294 # if !defined (__BORLANDC__) || (__BORLANDC__ >= 0x590) 295 typedef _ConversionHelper<_Src, _Dst> _H; 296 enum { value = (sizeof(char) == sizeof(_H::_Test(false, _H::_MakeSource()))) }; 297 # else 298 enum { _Is1 = __type2bool<_IsConst<_Src>::_Ret>::_Ret }; 299 enum { _Is2 = _IsConvertible<_UnConstPtr<_Src>::_Type, _UnConstPtr<_Dst>::_Type>::value }; 300 enum { value = _Is1 ? 0 : _Is2 }; 301 # endif 302 typedef typename __bool2type<value>::_Ret _Ret; 303 }; 304 305 #else 306 template <class _Src, class _Dst> 307 struct _IsConvertible { 308 enum { value = 0 }; 309 typedef __false_type _Ret; 310 }; 311 312 template <class _Src, class _Dst> 313 struct _IsCVConvertible { 314 enum { value = 0 }; 315 typedef __false_type _Ret; 316 }; 317 #endif 318 319 _STLP_END_NAMESPACE 320 321 #endif /* _STLP_TYPE_MANIPS_H */ 322
