1 /* 2 * Copyright (c) 2003 3 * Francois Dumont 4 * 5 * This material is provided "as is", with absolutely no warranty expressed 6 * or implied. Any use is at your own risk. 7 * 8 * Permission to use or copy this software for any purpose is hereby granted 9 * without fee, provided the above notices are retained on all copies. 10 * Permission to modify the code and to distribute modified code is granted, 11 * provided the above notices are retained, and a notice that the code was 12 * modified is included with the above copyright notice. 13 * 14 */ 15 16 /* NOTE: This is an internal header file, included by other STL headers. 17 * You should not attempt to use it directly. 18 */ 19 20 #ifndef _STLP_POINTERS_SPEC_TOOLS_H 21 #define _STLP_POINTERS_SPEC_TOOLS_H 22 23 #ifndef _STLP_TYPE_TRAITS_H 24 # include <stl/type_traits.h> 25 #endif 26 27 _STLP_BEGIN_NAMESPACE 28 29 //Some usefull declarations: 30 template <class _Tp> struct less; 31 32 _STLP_MOVE_TO_PRIV_NAMESPACE 33 34 template <class _StorageT, class _ValueT, class _BinaryPredicate> 35 struct _BinaryPredWrapper; 36 37 /* 38 * Since the compiler only allows at most one non-trivial 39 * implicit conversion we can make use of a shim class to 40 * be sure that functions below doesn't accept classes with 41 * implicit pointer conversion operators 42 */ 43 struct _VoidPointerShim 44 { _VoidPointerShim(void*); }; 45 struct _ConstVoidPointerShim 46 { _ConstVoidPointerShim(const void*); }; 47 struct _VolatileVoidPointerShim 48 { _VolatileVoidPointerShim(volatile void*); }; 49 struct _ConstVolatileVoidPointerShim 50 { _ConstVolatileVoidPointerShim(const volatile void*); }; 51 52 //The dispatch functions: 53 template <class _Tp> 54 char _UseVoidPtrStorageType(const __false_type& /*POD*/, const _Tp&); 55 char _UseVoidPtrStorageType(const __true_type& /*POD*/, ...); 56 char* _UseVoidPtrStorageType(const __true_type& /*POD*/, _VoidPointerShim); 57 58 template <class _Tp> 59 char _UseConstVoidPtrStorageType(const __false_type& /*POD*/, const _Tp&); 60 char _UseConstVoidPtrStorageType(const __true_type& /*POD*/, ...); 61 char* _UseConstVoidPtrStorageType(const __true_type& /*POD*/, _ConstVoidPointerShim); 62 63 template <class _Tp> 64 char _UseVolatileVoidPtrStorageType(const __false_type& /*POD*/, const _Tp&); 65 char _UseVolatileVoidPtrStorageType(const __true_type& /*POD*/, ...); 66 char* _UseVolatileVoidPtrStorageType(const __true_type& /*POD*/, _VolatileVoidPointerShim); 67 68 template <class _Tp> 69 char _UseConstVolatileVoidPtrStorageType(const __false_type& /*POD*/, const _Tp&); 70 char _UseConstVolatileVoidPtrStorageType(const __true_type& /*POD*/, ...); 71 char* _UseConstVolatileVoidPtrStorageType(const __true_type& /*POD*/, _ConstVolatileVoidPointerShim); 72 73 #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) 74 /* Thanks to class partial specialization the pointer specialization feature can even be used in 75 * presence of incomplete type: 76 * struct MyStruct { 77 * typedef vector<MyStruct> MyStructContainer; 78 * typedef MyStructContainer::iterator MyStructIterator; 79 * }; 80 */ 81 82 template <class _Tp> 83 struct _StorageType { 84 typedef _Tp _QualifiedType; 85 typedef _Tp _Type; 86 enum { use_const_volatile_void_ptr = 0 }; 87 }; 88 89 template <class _Tp> 90 struct _StorageType<_Tp*> { 91 // Even if we detect a pointer type we use dispatch function to consider if it can be stored as a void*. 92 // For instance function pointer might not necessarily be convertible to void*. 93 enum { use_void_ptr = (sizeof(_STLP_PRIV _UseVoidPtrStorageType(__true_type(), 94 __STATIC_CAST(_Tp*, 0))) == sizeof(char*)) }; 95 enum { use_const_volatile_void_ptr = use_void_ptr }; 96 typedef typename __select<use_void_ptr, 97 void*, 98 _Tp*>::_Ret _QualifiedType; 99 typedef _QualifiedType _Type; 100 }; 101 102 template <class _Tp> 103 struct _StorageType<_Tp const*> { 104 enum { use_void_ptr = (sizeof(_STLP_PRIV _UseConstVoidPtrStorageType(__true_type(), 105 __STATIC_CAST(const _Tp*, 0))) == sizeof(char*)) }; 106 enum { use_const_volatile_void_ptr = use_void_ptr }; 107 typedef typename __select<use_void_ptr, 108 const void*, 109 const _Tp*>::_Ret _QualifiedType; 110 typedef typename __select<use_void_ptr, 111 void*, 112 const _Tp*>::_Ret _Type; 113 }; 114 115 template <class _Tp> 116 struct _StorageType<_Tp volatile*> { 117 enum { use_void_ptr = (sizeof(_STLP_PRIV _UseVolatileVoidPtrStorageType(__true_type(), 118 __STATIC_CAST(_Tp volatile*, 0))) == sizeof(char*)) }; 119 enum { use_const_volatile_void_ptr = use_void_ptr }; 120 typedef typename __select<use_void_ptr, 121 volatile void*, 122 volatile _Tp*>::_Ret _QualifiedType; 123 typedef typename __select<use_void_ptr, 124 void*, 125 volatile _Tp*>::_Ret _Type; 126 }; 127 128 template <class _Tp> 129 struct _StorageType<_Tp const volatile*> { 130 enum { use_void_ptr = (sizeof(_STLP_PRIV _UseConstVolatileVoidPtrStorageType(__true_type(), 131 __STATIC_CAST(_Tp const volatile*, 0))) == sizeof(char*)) }; 132 enum { use_const_volatile_void_ptr = use_void_ptr }; 133 typedef typename __select<use_void_ptr, 134 const volatile void*, 135 const volatile _Tp*>::_Ret _QualifiedType; 136 typedef typename __select<use_void_ptr, 137 void*, 138 const volatile _Tp*>::_Ret _Type; 139 }; 140 #else 141 template <class _Tp> 142 struct _StorageType { 143 typedef typename __type_traits<_Tp>::is_POD_type _PODType; 144 145 #if !defined (__BORLANDC__) || (__BORLANDC__ != 0x560) 146 static _Tp __null_rep(); 147 #else 148 static _Tp __null_rep; 149 #endif 150 enum { use_void_ptr = (sizeof(_STLP_PRIV _UseVoidPtrStorageType(_PODType(), __null_rep())) == sizeof(char*)) }; 151 enum { use_const_void_ptr = (sizeof(_STLP_PRIV _UseConstVoidPtrStorageType(_PODType(), __null_rep())) == sizeof(char*)) }; 152 enum { use_volatile_void_ptr = (sizeof(_STLP_PRIV _UseVolatileVoidPtrStorageType(_PODType(), __null_rep())) == sizeof(char*)) }; 153 enum { use_const_volatile_void_ptr = (sizeof(_STLP_PRIV _UseConstVolatileVoidPtrStorageType(_PODType(), __null_rep())) == sizeof(char*)) }; 154 155 typedef typename __select<!use_const_volatile_void_ptr, 156 _Tp, 157 typename __select<use_void_ptr, 158 void*, 159 typename __select<use_const_void_ptr, 160 const void*, 161 typename __select<use_volatile_void_ptr, 162 volatile void*, 163 const volatile void*>::_Ret >::_Ret >::_Ret >::_Ret _QualifiedType; 164 165 #if !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) 166 /* If the compiler do not support the iterator_traits structure we cannot wrap 167 * iterators pass to container template methods. The iterator dereferenced value 168 * has to be storable without any cast in the chosen storage type. To guaranty 169 * that the void pointer has to be correctly qualified. 170 */ 171 typedef _QualifiedType _Type; 172 #else 173 /* With iterator_traits we can wrap passed iterators and make the necessary casts. 174 * We can always use a simple void* storage type: 175 */ 176 typedef typename __select<use_const_volatile_void_ptr, 177 void*, 178 _Tp>::_Ret _Type; 179 #endif 180 }; 181 #endif 182 183 template <class _Tp, class _Compare> 184 struct _AssocStorageTypes { 185 typedef _StorageType<_Tp> _StorageTypeInfo; 186 typedef typename _StorageTypeInfo::_Type _SType; 187 188 //We need to also check that the comparison functor used to instanciate the assoc container 189 //is the default Standard less implementation: 190 enum { ptr_type = _StorageTypeInfo::use_const_volatile_void_ptr }; 191 typedef typename _IsSTLportClass<_Compare>::_Ret _STLportLess; 192 enum { is_default_less = __type2bool<_STLportLess>::_Ret }; 193 typedef typename __select<is_default_less, _SType, _Tp>::_Ret _KeyStorageType; 194 typedef typename __select<is_default_less && ptr_type, 195 _BinaryPredWrapper<_KeyStorageType, _Tp, _Compare>, 196 _Compare>::_Ret _CompareStorageType; 197 }; 198 199 200 #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) 201 /* 202 * Base struct to deal with qualifiers 203 */ 204 template <class _StorageT, class _QualifiedStorageT> 205 struct _VoidCastTraitsAux { 206 typedef _QualifiedStorageT void_cv_type; 207 typedef _StorageT void_type; 208 209 static void_type * uncv_ptr(void_cv_type *__ptr) 210 { return __ptr; } 211 static void_type const* uncv_cptr(void_cv_type const*__ptr) 212 { return __ptr; } 213 static void_type ** uncv_pptr(void_cv_type **__ptr) 214 { return __ptr; } 215 static void_type & uncv_ref(void_cv_type & __ref) 216 { return __ref; } 217 static void_type const& uncv_cref(void_cv_type const& __ref) 218 { return __ref; } 219 static void_cv_type* cv_ptr(void_type *__ptr) 220 { return __ptr; } 221 static void_cv_type const* cv_cptr(void_type const*__ptr) 222 { return __ptr; } 223 static void_cv_type ** cv_pptr(void_type **__ptr) 224 { return __ptr; } 225 static void_cv_type & cv_ref(void_type & __ref) 226 { return __ref; } 227 static void_cv_type const& cv_cref(void_type const& __ref) 228 { return __ref; } 229 }; 230 231 template <class _VoidCVType> 232 struct _VoidCastTraitsAuxBase { 233 typedef _VoidCVType* void_cv_type; 234 typedef void* void_type; 235 236 static void_type* uncv_ptr(void_cv_type *__ptr) 237 { return __CONST_CAST(void_type*, __ptr); } 238 static void_type const* uncv_cptr(void_cv_type const*__ptr) 239 { return __CONST_CAST(void_type const*, __ptr); } 240 static void_type** uncv_pptr(void_cv_type **__ptr) 241 { return __CONST_CAST(void_type**, __ptr); } 242 static void_type& uncv_ref(void_cv_type &__ref) 243 { return __CONST_CAST(void_type&, __ref); } 244 static void_type const& uncv_cref(void_cv_type const& __ptr) 245 { return __CONST_CAST(void_type const&, __ptr); } 246 // The reverse versions 247 static void_cv_type * cv_ptr(void_type *__ptr) 248 { return __CONST_CAST(void_cv_type *, __ptr); } 249 static void_cv_type const* cv_cptr(void_type const*__ptr) 250 { return __CONST_CAST(void_cv_type const*, __ptr); } 251 static void_cv_type ** cv_pptr(void_type **__ptr) 252 { return __CONST_CAST(void_cv_type**, __ptr); } 253 static void_cv_type & cv_ref(void_type &__ref) 254 { return __CONST_CAST(void_cv_type &, __ref); } 255 static void_cv_type const& cv_cref(void_type const& __ref) 256 { return __CONST_CAST(void_cv_type const&, __ref); } 257 }; 258 259 _STLP_TEMPLATE_NULL 260 struct _VoidCastTraitsAux<void*, const void*> : _VoidCastTraitsAuxBase<void const> 261 {}; 262 _STLP_TEMPLATE_NULL 263 struct _VoidCastTraitsAux<void*, volatile void*> : _VoidCastTraitsAuxBase<void volatile> 264 {}; 265 _STLP_TEMPLATE_NULL 266 struct _VoidCastTraitsAux<void*, const volatile void*> : _VoidCastTraitsAuxBase<void const volatile> 267 {}; 268 269 template <class _StorageT, class _ValueT> 270 struct _CastTraits { 271 typedef _ValueT value_type; 272 typedef typename _StorageType<_ValueT>::_QualifiedType _QualifiedStorageT; 273 typedef _VoidCastTraitsAux<_StorageT, _QualifiedStorageT> cv_traits; 274 typedef typename cv_traits::void_type void_type; 275 typedef typename cv_traits::void_cv_type void_cv_type; 276 277 static value_type * to_value_type_ptr(void_type *__ptr) 278 { return __REINTERPRET_CAST(value_type *, cv_traits::cv_ptr(__ptr)); } 279 static value_type const* to_value_type_cptr(void_type const*__ptr) 280 { return __REINTERPRET_CAST(value_type const*, cv_traits::cv_cptr(__ptr)); } 281 static value_type ** to_value_type_pptr(void_type **__ptr) 282 { return __REINTERPRET_CAST(value_type **, cv_traits::cv_pptr(__ptr)); } 283 static value_type & to_value_type_ref(void_type &__ref) 284 { return __REINTERPRET_CAST(value_type &, cv_traits::cv_ref(__ref)); } 285 static value_type const& to_value_type_cref(void_type const& __ptr) 286 { return __REINTERPRET_CAST(value_type const&, cv_traits::cv_cref(__ptr)); } 287 // Reverse versions 288 static void_type * to_storage_type_ptr(value_type *__ptr) 289 { return cv_traits::uncv_ptr(__REINTERPRET_CAST(void_cv_type *, __ptr)); } 290 static void_type const* to_storage_type_cptr(value_type const*__ptr) 291 { return cv_traits::uncv_cptr(__REINTERPRET_CAST(void_cv_type const*, __ptr)); } 292 static void_type ** to_storage_type_pptr(value_type **__ptr) 293 { return cv_traits::uncv_pptr(__REINTERPRET_CAST(void_cv_type **, __ptr)); } 294 static void_type const& to_storage_type_cref(value_type const& __ref) 295 { return cv_traits::uncv_cref(__REINTERPRET_CAST(void_cv_type const&, __ref)); } 296 297 //Method used to treat set container template method extension 298 static void_type const& to_storage_type_crefT(value_type const& __ref) 299 { return to_storage_type_cref(__ref); } 300 }; 301 302 template <class _Tp> 303 struct _CastTraits<_Tp, _Tp> { 304 typedef _Tp storage_type; 305 typedef _Tp value_type; 306 307 static value_type * to_value_type_ptr(storage_type *__ptr) 308 { return __ptr; } 309 static value_type const* to_value_type_cptr(storage_type const*__ptr) 310 { return __ptr; } 311 static value_type ** to_value_type_pptr(storage_type **__ptr) 312 { return __ptr; } 313 static value_type & to_value_type_ref(storage_type &__ref) 314 { return __ref; } 315 static value_type const& to_value_type_cref(storage_type const&__ref) 316 { return __ref; } 317 // Reverse versions 318 static storage_type * to_storage_type_ptr(value_type *__ptr) 319 { return __ptr; } 320 static storage_type const* to_storage_type_cptr(value_type const*__ptr) 321 { return __ptr; } 322 static storage_type ** to_storage_type_pptr(value_type **__ptr) 323 { return __ptr; } 324 static storage_type const& to_storage_type_cref(value_type const& __ref) 325 { return __ref; } 326 327 //Method used to treat set container template method extension 328 template <class _Tp1> 329 static _Tp1 const& to_storage_type_crefT(_Tp1 const& __ref) 330 { return __ref; } 331 }; 332 333 #define _STLP_USE_ITERATOR_WRAPPER 334 335 template <class _StorageT, class _ValueT, class _Iterator> 336 struct _IteWrapper { 337 typedef _CastTraits<_StorageT, _ValueT> cast_traits; 338 typedef iterator_traits<_Iterator> _IteTraits; 339 340 typedef typename _IteTraits::iterator_category iterator_category; 341 typedef _StorageT value_type; 342 typedef typename _IteTraits::difference_type difference_type; 343 typedef value_type* pointer; 344 typedef value_type const& const_reference; 345 //This wrapper won't be used for input so to avoid surprise 346 //the reference type will be a const reference: 347 typedef const_reference reference; 348 349 typedef _IteWrapper<_StorageT, _ValueT, _Iterator> _Self; 350 typedef _Self _Ite; 351 352 _IteWrapper(_Iterator &__ite) : _M_ite(__ite) {} 353 354 const_reference operator*() const 355 // See http://code.google.com/p/android/issues/detail?id=38630 356 //{ return cast_traits::to_storage_type_cref(*_M_ite); } 357 { return __REINTERPRET_CAST(const_reference, *_M_ite); } 358 359 _Self& operator= (_Self const& __rhs) { 360 _M_ite = __rhs._M_ite; 361 return *this; 362 } 363 364 _Self& operator++() { 365 ++_M_ite; 366 return *this; 367 } 368 369 _Self& operator--() { 370 --_M_ite; 371 return *this; 372 } 373 374 _Self& operator += (difference_type __offset) { 375 _M_ite += __offset; 376 return *this; 377 } 378 difference_type operator -(_Self const& __other) const 379 { return _M_ite - __other._M_ite; } 380 381 bool operator == (_Self const& __other) const 382 { return _M_ite == __other._M_ite; } 383 384 bool operator != (_Self const& __other) const 385 { return _M_ite != __other._M_ite; } 386 387 bool operator < (_Self const& __rhs) const 388 { return _M_ite < __rhs._M_ite; } 389 390 private: 391 _Iterator _M_ite; 392 }; 393 394 template <class _Tp, class _Iterator> 395 struct _IteWrapper<_Tp, _Tp, _Iterator> 396 { typedef _Iterator _Ite; }; 397 398 #else 399 400 /* 401 * In this config the storage type is qualified in respect of the 402 * value_type qualification. Simple reinterpret_cast is enough. 403 */ 404 template <class _StorageT, class _ValueT> 405 struct _CastTraits { 406 typedef _StorageT storage_type; 407 typedef _ValueT value_type; 408 409 static value_type * to_value_type_ptr(storage_type *__ptr) 410 { return __REINTERPRET_CAST(value_type*, __ptr); } 411 static value_type const* to_value_type_cptr(storage_type const*__ptr) 412 { return __REINTERPRET_CAST(value_type const*, __ptr); } 413 static value_type ** to_value_type_pptr(storage_type **__ptr) 414 { return __REINTERPRET_CAST(value_type **, __ptr); } 415 static value_type & to_value_type_ref(storage_type &__ref) 416 { return __REINTERPRET_CAST(value_type&, __ref); } 417 static value_type const& to_value_type_cref(storage_type const&__ref) 418 { return __REINTERPRET_CAST(value_type const&, __ref); } 419 // Reverse versions 420 static storage_type * to_storage_type_ptr(value_type *__ptr) 421 { return __REINTERPRET_CAST(storage_type*, __ptr); } 422 static storage_type const* to_storage_type_cptr(value_type const*__ptr) 423 { return __REINTERPRET_CAST(storage_type const*, __ptr); } 424 static storage_type ** to_storage_type_pptr(value_type **__ptr) 425 { return __REINTERPRET_CAST(storage_type **, __ptr); } 426 static storage_type const& to_storage_type_cref(value_type const&__ref) 427 { return __REINTERPRET_CAST(storage_type const&, __ref); } 428 template <class _Tp1> 429 static _Tp1 const& to_storage_type_crefT(_Tp1 const& __ref) 430 { return __ref; } 431 }; 432 433 #endif 434 435 //Wrapper functors: 436 template <class _StorageT, class _ValueT, class _UnaryPredicate> 437 struct _UnaryPredWrapper { 438 typedef _CastTraits<_StorageT, _ValueT> cast_traits; 439 440 _UnaryPredWrapper (_UnaryPredicate const& __pred) : _M_pred(__pred) {} 441 442 bool operator () (_StorageT const& __ref) const 443 { return _M_pred(cast_traits::to_value_type_cref(__ref)); } 444 445 private: 446 _UnaryPredicate _M_pred; 447 }; 448 449 template <class _StorageT, class _ValueT, class _BinaryPredicate> 450 struct _BinaryPredWrapper { 451 typedef _CastTraits<_StorageT, _ValueT> cast_traits; 452 453 _BinaryPredWrapper () {} 454 _BinaryPredWrapper (_BinaryPredicate const& __pred) : _M_pred(__pred) {} 455 456 _BinaryPredicate get_pred() const { return _M_pred; } 457 458 bool operator () (_StorageT const& __fst, _StorageT const& __snd) const 459 { return _M_pred(cast_traits::to_value_type_cref(__fst), cast_traits::to_value_type_cref(__snd)); } 460 461 //Cast operator used to transparently access underlying predicate 462 //in set::key_comp() method 463 operator _BinaryPredicate() const 464 { return _M_pred; } 465 466 private: 467 _BinaryPredicate _M_pred; 468 }; 469 470 _STLP_MOVE_TO_STD_NAMESPACE 471 472 _STLP_END_NAMESPACE 473 474 #endif /* _STLP_POINTERS_SPEC_TOOLS_H */ 475
