00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00047 #ifndef STLSOFT_INCL_STLSOFT_META_HPP_BASE_TYPE_TRAITS
00048 #define STLSOFT_INCL_STLSOFT_META_HPP_BASE_TYPE_TRAITS
00049
00050 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00051 # define STLSOFT_VER_STLSOFT_META_HPP_BASE_TYPE_TRAITS_MAJOR 4
00052 # define STLSOFT_VER_STLSOFT_META_HPP_BASE_TYPE_TRAITS_MINOR 2
00053 # define STLSOFT_VER_STLSOFT_META_HPP_BASE_TYPE_TRAITS_REVISION 1
00054 # define STLSOFT_VER_STLSOFT_META_HPP_BASE_TYPE_TRAITS_EDIT 36
00055 #endif
00056
00057
00058
00059
00060
00061 #ifndef STLSOFT_INCL_STLSOFT_H_STLSOFT
00062 # include <stlsoft/stlsoft.h>
00063 #endif
00064
00065
00066
00067
00068
00069 #ifndef _STLSOFT_NO_NAMESPACE
00070 namespace stlsoft
00071 {
00072 #endif
00073
00074
00075
00076
00077
00078 #ifdef STLSOFT_CF_TEMPLATE_PARTIAL_SPECIALISATION_SUPPORT
00079
00080 # ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00081
00082 # if defined(STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT)
00083 template <ss_typename_param_k T>
00084 struct base_type_traits_array_detector
00085 {
00086 enum { value = 0 };
00087 };
00088
00089 template< ss_typename_param_k T
00090 , ss_size_t N
00091 >
00092 struct base_type_traits_array_detector<T[N]>
00093 {
00094 enum { value = 1 };
00095 };
00096 # endif
00097
00098 template <ss_typename_param_k T>
00099 struct base_type_traits_pointer_detector
00100 {
00101 enum { value = 0 };
00102 };
00103
00104 template <ss_typename_param_k T>
00105 struct base_type_traits_pointer_detector<T*>
00106 {
00107 enum { value = 1 };
00108 };
00109 template <ss_typename_param_k T>
00110 struct base_type_traits_pointer_detector<T const*>
00111 {
00112 enum { value = 1 };
00113 };
00114 template <ss_typename_param_k T>
00115 struct base_type_traits_pointer_detector<T volatile*>
00116 {
00117 enum { value = 1 };
00118 };
00119 template <ss_typename_param_k T>
00120 struct base_type_traits_pointer_detector<T const volatile*>
00121 {
00122 enum { value = 1 };
00123 };
00124
00125 # endif
00126
00127
00128
00133 template <ss_typename_param_k T>
00134 struct base_type_traits
00135 {
00136 enum { is_pointer = base_type_traits_pointer_detector<T>::value };
00137 enum { is_reference = 0 };
00138 enum { is_const = 0 };
00139 enum { is_volatile = 0 };
00140 enum { is_array_or_pointer = 0 };
00141 #if defined(STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT)
00142 enum { is_array = base_type_traits_array_detector<T>::value };
00143 #endif
00144
00145 typedef T base_type;
00146 typedef T cv_type;
00147 };
00148
00149 # ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00150
00151
00152
00153 # if !defined(STLSOFT_COMPILER_IS_BORLAND) || \
00154 __BORLANDC__ >= 0x0564
00155
00156 template <ss_typename_param_k T>
00157 struct base_type_traits<const T>
00158 {
00159 enum { is_pointer = 0 };
00160 enum { is_reference = 0 };
00161 enum { is_const = 1 };
00162 enum { is_volatile = 0 };
00163 enum { is_array_or_pointer = 0 };
00164 #if defined(STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT)
00165 enum { is_array = base_type_traits_array_detector<T>::value };
00166 #endif
00167
00168 typedef T base_type;
00169 typedef T cv_type;
00170 };
00171
00172 template <ss_typename_param_k T>
00173 struct base_type_traits<volatile T>
00174 {
00175 enum { is_pointer = 0 };
00176 enum { is_reference = 0 };
00177 enum { is_const = 0 };
00178 enum { is_volatile = 1 };
00179 enum { is_array_or_pointer = 0 };
00180 #if defined(STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT)
00181 enum { is_array = base_type_traits_array_detector<T>::value };
00182 #endif
00183
00184 typedef T base_type;
00185 typedef T cv_type;
00186 };
00187
00188 template <ss_typename_param_k T>
00189 struct base_type_traits<const volatile T>
00190 {
00191 enum { is_pointer = 0 };
00192 enum { is_reference = 0 };
00193 enum { is_const = 1 };
00194 enum { is_volatile = 1 };
00195 enum { is_array_or_pointer = 0 };
00196 #if defined(STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT)
00197 enum { is_array = base_type_traits_array_detector<T>::value };
00198 #endif
00199
00200 typedef T base_type;
00201 typedef T cv_type;
00202 };
00203
00204 # endif
00205
00206
00207
00208 template <ss_typename_param_k T>
00209 struct base_type_traits<T*>
00210 {
00211 enum { is_pointer = 1 };
00212 enum { is_reference = 0 };
00213 enum { is_const = 0 };
00214 enum { is_volatile = 0 };
00215 enum { is_array_or_pointer = 1 };
00216 #if defined(STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT)
00217 enum { is_array = base_type_traits_array_detector<T>::value };
00218 #endif
00219
00220 typedef T base_type;
00221 typedef T cv_type;
00222 };
00223
00224 template <ss_typename_param_k T>
00225 struct base_type_traits<T const*>
00226 {
00227 enum { is_pointer = 1 };
00228 enum { is_reference = 0 };
00229 enum { is_const = 1 };
00230 enum { is_volatile = 0 };
00231 enum { is_array_or_pointer = 1 };
00232 #if defined(STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT)
00233 enum { is_array = 0 };
00234 #endif
00235
00236 typedef T base_type;
00237 typedef T const cv_type;
00238 };
00239
00240 template <ss_typename_param_k T>
00241 struct base_type_traits<T volatile*>
00242 {
00243 enum { is_pointer = 1 };
00244 enum { is_reference = 0 };
00245 enum { is_const = 0 };
00246 enum { is_volatile = 1 };
00247 enum { is_array_or_pointer = 1 };
00248 #if defined(STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT)
00249 enum { is_array = 0 };
00250 #endif
00251
00252 typedef T base_type;
00253 typedef T volatile cv_type;
00254 };
00255
00256 template <ss_typename_param_k T>
00257 struct base_type_traits<T const volatile*>
00258 {
00259 enum { is_pointer = 1 };
00260 enum { is_reference = 0 };
00261 enum { is_const = 1 };
00262 enum { is_volatile = 1 };
00263 enum { is_array_or_pointer = 1 };
00264 #if defined(STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT)
00265 enum { is_array = 0 };
00266 #endif
00267
00268 typedef T base_type;
00269 typedef T const volatile cv_type;
00270 };
00271
00272
00273
00274 # if defined(STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT)
00275
00276 #if 0
00277 template <ss_typename_param_k T, ss_size_t N>
00278 struct base_type_traits<T[N]>
00279 {
00280 enum { is_pointer = 0 };
00281 enum { is_reference = 0 };
00282 enum { is_const = 0 };
00283 enum { is_volatile = 0 };
00284 enum { is_array = 1 };
00285 enum { is_array_or_pointer = 1 };
00286
00287 typedef T base_type;
00288 typedef T cv_type;
00289 };
00290
00291 template <ss_typename_param_k T, ss_size_t N>
00292 struct base_type_traits<T const[N]>
00293 {
00294 enum { is_pointer = 0 };
00295 enum { is_reference = 0 };
00296 enum { is_const = 1 };
00297 enum { is_volatile = 0 };
00298 enum { is_array = 1 };
00299 enum { is_array_or_pointer = 1 };
00300
00301 typedef T base_type;
00302 typedef T const cv_type;
00303 };
00304
00305 template <ss_typename_param_k T, ss_size_t N>
00306 struct base_type_traits<T volatile[N]>
00307 {
00308 enum { is_pointer = 0 };
00309 enum { is_reference = 0 };
00310 enum { is_const = 0 };
00311 enum { is_volatile = 1 };
00312 enum { is_array = 1 };
00313 enum { is_array_or_pointer = 1 };
00314
00315 typedef T base_type;
00316 typedef T volatile cv_type;
00317 };
00318
00319 template <ss_typename_param_k T, ss_size_t N>
00320 struct base_type_traits<T const volatile[N]>
00321 {
00322 enum { is_pointer = 0 };
00323 enum { is_reference = 0 };
00324 enum { is_const = 1 };
00325 enum { is_volatile = 1 };
00326 enum { is_array = 1 };
00327 enum { is_array_or_pointer = 1 };
00328
00329 typedef T base_type;
00330 typedef T const volatile cv_type;
00331 };
00332 #endif
00333
00334 # endif
00335
00336
00337
00338 template <ss_typename_param_k T>
00339 struct base_type_traits<T&>
00340 {
00341 enum { is_pointer = 0 };
00342 enum { is_reference = 1 };
00343 enum { is_const = 0 };
00344 enum { is_volatile = 0 };
00345 enum { is_array_or_pointer = 0 };
00346 #if defined(STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT)
00347 enum { is_array = base_type_traits_array_detector<T>::value };
00348 #endif
00349
00350 typedef T base_type;
00351 typedef T cv_type;
00352 };
00353
00354 template <ss_typename_param_k T>
00355 struct base_type_traits<T const&>
00356 {
00357 enum { is_pointer = 0 };
00358 enum { is_reference = 1 };
00359 enum { is_const = 1 };
00360 enum { is_volatile = 0 };
00361 enum { is_array_or_pointer = 0 };
00362 #if defined(STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT)
00363 enum { is_array = base_type_traits_array_detector<T>::value };
00364 #endif
00365
00366 typedef T base_type;
00367 typedef T const cv_type;
00368 };
00369
00370 template <ss_typename_param_k T>
00371 struct base_type_traits<T volatile&>
00372 {
00373 enum { is_pointer = 0 };
00374 enum { is_reference = 1 };
00375 enum { is_const = 0 };
00376 enum { is_volatile = 1 };
00377 enum { is_array_or_pointer = 0 };
00378 #if defined(STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT)
00379 enum { is_array = base_type_traits_array_detector<T>::value };
00380 #endif
00381
00382 typedef T base_type;
00383 typedef T volatile cv_type;
00384 };
00385
00386 template <ss_typename_param_k T>
00387 struct base_type_traits<T const volatile&>
00388 {
00389 enum { is_pointer = 0 };
00390 enum { is_reference = 1 };
00391 enum { is_const = 1 };
00392 enum { is_volatile = 1 };
00393 enum { is_array_or_pointer = 0 };
00394 #if defined(STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT)
00395 enum { is_array = base_type_traits_array_detector<T>::value };
00396 #endif
00397
00398 typedef T base_type;
00399 typedef T const volatile cv_type;
00400 };
00401
00402
00403
00404 template <ss_typename_param_k T>
00405 struct base_type_traits<T*&>
00406 {
00407 enum { is_pointer = 1 };
00408 enum { is_reference = 1 };
00409 enum { is_const = 0 };
00410 enum { is_volatile = 0 };
00411 enum { is_array_or_pointer = 1 };
00412 #if defined(STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT)
00413 enum { is_array = 0 };
00414 #endif
00415
00416 typedef T base_type;
00417 typedef T cv_type;
00418 };
00419
00420 template <ss_typename_param_k T>
00421 struct base_type_traits<T const*&>
00422 {
00423 enum { is_pointer = 1 };
00424 enum { is_reference = 1 };
00425 enum { is_const = 1 };
00426 enum { is_volatile = 0 };
00427 enum { is_array_or_pointer = 1 };
00428 #if defined(STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT)
00429 enum { is_array = 0 };
00430 #endif
00431
00432 typedef T base_type;
00433 typedef T const cv_type;
00434 };
00435
00436 template <ss_typename_param_k T>
00437 struct base_type_traits<T volatile*&>
00438 {
00439 enum { is_pointer = 1 };
00440 enum { is_reference = 1 };
00441 enum { is_const = 0 };
00442 enum { is_volatile = 1 };
00443 enum { is_array_or_pointer = 1 };
00444 #if defined(STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT)
00445 enum { is_array = 0 };
00446 #endif
00447
00448 typedef T base_type;
00449 typedef T volatile cv_type;
00450 };
00451
00452 template <ss_typename_param_k T>
00453 struct base_type_traits<T const volatile*&>
00454 {
00455 enum { is_pointer = 1 };
00456 enum { is_reference = 1 };
00457 enum { is_const = 1 };
00458 enum { is_volatile = 1 };
00459 enum { is_array_or_pointer = 1 };
00460 #if defined(STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT)
00461 enum { is_array = 0 };
00462 #endif
00463
00464 typedef T base_type;
00465 typedef T const volatile cv_type;
00466 };
00467
00468 # endif
00469
00470 #else
00471
00472 #endif
00473
00474
00475
00476
00477
00478 #ifdef STLSOFT_UNITTEST
00479 # include "./unittest/base_type_traits_unittest_.h"
00480 #endif
00481
00482
00483
00484 #ifndef _STLSOFT_NO_NAMESPACE
00485 }
00486 #endif
00487
00488
00489
00490 #endif
00491
00492