ReactOS  0.4.13-dev-92-gf251225
type_traits.h
Go to the documentation of this file.
1 /*
2  *
3  * Copyright (c) 1996,1997
4  * Silicon Graphics Computer Systems, Inc.
5  *
6  * Copyright (c) 1997
7  * Moscow Center for SPARC Technology
8  *
9  * Copyright (c) 1999
10  * Boris Fomitchev
11  *
12  * This material is provided "as is", with absolutely no warranty expressed
13  * or implied. Any use is at your own risk.
14  *
15  * Permission to use or copy this software for any purpose is hereby granted
16  * without fee, provided the above notices are retained on all copies.
17  * Permission to modify the code and to distribute modified code is granted,
18  * provided the above notices are retained, and a notice that the code was
19  * modified is included with the above copyright notice.
20  *
21  */
22 
23 #ifndef _STLP_TYPE_TRAITS_H
24 #define _STLP_TYPE_TRAITS_H
25 
26 /*
27 This header file provides a framework for allowing compile time dispatch
28 based on type attributes. This is useful when writing template code.
29 For example, when making a copy of an array of an unknown type, it helps
30 to know if the type has a trivial copy constructor or not, to help decide
31 if a memcpy can be used.
32 
33 The class template __type_traits provides a series of typedefs each of
34 which is either __true_type or __false_type. The argument to
35 __type_traits can be any type. The typedefs within this template will
36 attain their correct values by one of these means:
37  1. The general instantiation contain conservative values which work
38  for all types.
39  2. Specializations may be declared to make distinctions between types.
40  3. Some compilers (such as the Silicon Graphics N32 and N64 compilers)
41  will automatically provide the appropriate specializations for all
42  types.
43 
44 EXAMPLE:
45 
46 //Copy an array of elements which have non-trivial copy constructors
47 template <class T> void copy(T* source, T* destination, int n, __false_type);
48 //Copy an array of elements which have trivial copy constructors. Use memcpy.
49 template <class T> void copy(T* source, T* destination, int n, __true_type);
50 
51 //Copy an array of any type by using the most efficient copy mechanism
52 template <class T> inline void copy(T* source,T* destination,int n) {
53  copy(source, destination, n,
54  typename __type_traits<T>::has_trivial_copy_constructor());
55 }
56 */
57 
58 #ifdef __WATCOMC__
59 # include <stl/_cwchar.h>
60 #endif
61 
62 #ifndef _STLP_TYPE_MANIPS_H
63 # include <stl/type_manips.h>
64 #endif
65 
66 #ifdef _STLP_USE_BOOST_SUPPORT
67 # include <stl/boost_type_traits.h>
68 # include <boost/type_traits/add_reference.hpp>
69 # include <boost/type_traits/add_const.hpp>
70 #endif /* _STLP_USE_BOOST_SUPPORT */
71 
73 
74 #if !defined (_STLP_USE_BOOST_SUPPORT)
75 
76 // The following could be written in terms of numeric_limits.
77 // We're doing it separately to reduce the number of dependencies.
78 
79 template <class _Tp> struct _IsIntegral
80 { typedef __false_type _Ret; };
81 
82 # ifndef _STLP_NO_BOOL
84 { typedef __true_type _Ret; };
85 # endif /* _STLP_NO_BOOL */
86 
88 { typedef __true_type _Ret; };
89 
90 # ifndef _STLP_NO_SIGNED_BUILTINS
92 { typedef __true_type _Ret; };
93 # endif
94 
96 { typedef __true_type _Ret; };
97 
98 # if defined ( _STLP_HAS_WCHAR_T ) && ! defined (_STLP_WCHAR_T_IS_USHORT)
100 { typedef __true_type _Ret; };
101 # endif /* _STLP_HAS_WCHAR_T */
102 
104 { typedef __true_type _Ret; };
105 
107 { typedef __true_type _Ret; };
108 
110 { typedef __true_type _Ret; };
111 
113 { typedef __true_type _Ret; };
114 
116 { typedef __true_type _Ret; };
117 
119 { typedef __true_type _Ret; };
120 
121 # ifdef _STLP_LONG_LONG
123 { typedef __true_type _Ret; };
124 
126 { typedef __true_type _Ret; };
127 # endif /* _STLP_LONG_LONG */
128 
129 template <class _Tp> struct _IsRational
130 { typedef __false_type _Ret; };
131 
133 { typedef __true_type _Ret; };
134 
136 { typedef __true_type _Ret; };
137 
138 # if !defined ( _STLP_NO_LONG_DOUBLE )
140 { typedef __true_type _Ret; };
141 # endif
142 
143 // Forward declarations.
144 template <class _Tp> struct __type_traits;
145 template <class _IsPOD> struct __type_traits_aux {
151 };
152 
160 };
161 
169 };
170 
171 template <class _Tp>
172 struct _IsRef {
174 };
175 
176 # if defined (_STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS)
177 /*
178  * Boris : simulation technique is used here according to Adobe Open Source License Version 1.0.
179  * Copyright 2000 Adobe Systems Incorporated and others. All rights reserved.
180  * Authors: Mat Marcus and Jesse Jones
181  * The original version of this source code may be found at
182  * http://opensource.adobe.com.
183  */
184 
185 struct _PointerShim {
186  /*
187  * Since the compiler only allows at most one non-trivial
188  * implicit conversion we can make use of a shim class to
189  * be sure that IsPtr below doesn't accept classes with
190  * implicit pointer conversion operators
191  */
192  _PointerShim(const volatile void*); // no implementation
193 };
194 
195 // These are the discriminating functions
196 char _STLP_CALL _IsP(bool, _PointerShim); // no implementation is required
197 char* _STLP_CALL _IsP(bool, ...); // no implementation is required
198 
199 template <class _Tp>
200 struct _IsPtr {
201  /*
202  * This template meta function takes a type T
203  * and returns true exactly when T is a pointer.
204  * One can imagine meta-functions discriminating on
205  * other criteria.
206  */
207  static _Tp& __null_rep();
208  enum { _Ptr = (sizeof(_IsP(false,__null_rep())) == sizeof(char)) };
209  typedef typename __bool2type<_Ptr>::_Ret _Ret;
210 
211 };
212 
213 // we make general case dependant on the fact the type is actually a pointer.
214 template <class _Tp>
215 struct __type_traits : __type_traits_aux<typename _IsPtr<_Tp>::_Ret> {};
216 
217 # else /* _STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS */
218 
219 template <class _Tp> struct _IsPtr {
221 };
222 
223 template <class _Tp>
224 struct __type_traits {
226  /* Do not remove this member. It informs a compiler which
227  automatically specializes __type_traits that this
228  __type_traits template is special. It just makes sure that
229  things work if an implementation is using a template
230  called __type_traits for something unrelated. */
231 
232  /* The following restrictions should be observed for the sake of
233  compilers which automatically produce type specific specializations
234  of this class:
235  - You may reorder the members below if you wish
236  - You may remove any of the members below if you wish
237  - You must not rename members without making the corresponding
238  name change in the compiler
239  - Members you add will be treated like regular members unless
240 
241  you add the appropriate support in the compiler. */
242 # if !defined (_STLP_HAS_TYPE_TRAITS_INTRINSICS)
248 # else
249  typedef typename __bool2type<_STLP_HAS_TRIVIAL_CONSTRUCTOR(_Tp)>::_Ret has_trivial_default_constructor;
250  typedef typename __bool2type<_STLP_HAS_TRIVIAL_COPY(_Tp)>::_Ret has_trivial_copy_constructor;
251  typedef typename __bool2type<_STLP_HAS_TRIVIAL_ASSIGN(_Tp)>::_Ret has_trivial_assignment_operator;
252  typedef typename __bool2type<_STLP_HAS_TRIVIAL_DESTRUCTOR(_Tp)>::_Ret has_trivial_destructor;
253  typedef typename __bool2type<_STLP_IS_POD(_Tp)>::_Ret is_POD_type;
254 # endif
255 };
256 
257 # if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
258 template <class _Tp> struct _IsPtr<_Tp*>
259 { typedef __true_type _Ret; };
260 template <class _Tp> struct _IsRef<_Tp&>
261 { typedef __true_type _Ret; };
262 
263 template <class _Tp> struct __type_traits<_Tp*> : __type_traits_aux<__true_type>
264 {};
265 # endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
266 
267 # endif /* _STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS */
268 
269 // Provide some specializations. This is harmless for compilers that
270 // have built-in __types_traits support, and essential for compilers
271 // that don't.
272 # if !defined (_STLP_QUALIFIED_SPECIALIZATION_BUG)
273 # define _STLP_DEFINE_TYPE_TRAITS_FOR(Type) \
274 _STLP_TEMPLATE_NULL struct __type_traits< Type > : __type_traits_aux<__true_type> {}; \
275 _STLP_TEMPLATE_NULL struct __type_traits< const Type > : __type_traits_aux<__true_type> {}; \
276 _STLP_TEMPLATE_NULL struct __type_traits< volatile Type > : __type_traits_aux<__true_type> {}; \
277 _STLP_TEMPLATE_NULL struct __type_traits< const volatile Type > : __type_traits_aux<__true_type> {}
278 # else
279 # define _STLP_DEFINE_TYPE_TRAITS_FOR(Type) \
280 _STLP_TEMPLATE_NULL struct __type_traits< Type > : __type_traits_aux<__true_type> {};
281 # endif
282 
283 # ifndef _STLP_NO_BOOL
285 # endif /* _STLP_NO_BOOL */
287 # ifndef _STLP_NO_SIGNED_BUILTINS
288 _STLP_DEFINE_TYPE_TRAITS_FOR(signed char);
289 # endif
290 _STLP_DEFINE_TYPE_TRAITS_FOR(unsigned char);
291 # if defined ( _STLP_HAS_WCHAR_T ) && ! defined (_STLP_WCHAR_T_IS_USHORT)
293 # endif /* _STLP_HAS_WCHAR_T */
294 
296 _STLP_DEFINE_TYPE_TRAITS_FOR(unsigned short);
298 _STLP_DEFINE_TYPE_TRAITS_FOR(unsigned int);
300 _STLP_DEFINE_TYPE_TRAITS_FOR(unsigned long);
301 
302 # ifdef _STLP_LONG_LONG
305 # endif /* _STLP_LONG_LONG */
306 
309 
310 # if !defined ( _STLP_NO_LONG_DOUBLE )
311 _STLP_DEFINE_TYPE_TRAITS_FOR(long double);
312 # endif
313 
314 # if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
315 template <class _ArePtrs, class _Src, class _Dst>
316 struct _IsCVConvertibleIf
317 { typedef typename _IsCVConvertible<_Src, _Dst>::_Ret _Ret; };
318 
319 template <class _Src, class _Dst>
320 struct _IsCVConvertibleIf<__false_type, _Src, _Dst>
321 { typedef __false_type _Ret; };
322 # else
323 # if defined (_STLP_MEMBER_TEMPLATE_CLASSES)
324 template <class _ArePtrs>
325 struct _IsCVConvertibleIfAux {
326  template <class _Src, class _Dst>
327  struct _In
328  { typedef typename _IsCVConvertible<_Src, _Dst>::_Ret _Ret; };
329 };
330 
332 struct _IsCVConvertibleIfAux<__false_type> {
333  template <class _Src, class _Dst>
334  struct _In
335  { typedef __false_type _Ret; };
336 };
337 
338 template <class _ArePtrs, class _Src, class _Dst>
339 struct _IsCVConvertibleIf {
340  typedef typename _IsCVConvertibleIfAux<_ArePtrs>::_STLP_TEMPLATE _In<_Src, _Dst>::_Ret _Ret;
341 };
342 # else
343 /* default behavior: we prefer to miss an optimization rather than taking the risk of
344  * a compilation error if playing with types with exotic memory alignment.
345  */
346 template <class _ArePtrs, class _Src, class _Dst>
348 { typedef __false_type _Ret; };
349 # endif
350 # endif
351 
352 template <class _Src, class _Dst>
354  typedef typename _IsPtr<_Src>::_Ret _Ptr1;
355  typedef typename _IsPtr<_Dst>::_Ret _Ptr2;
359 
360  typedef typename __bool2type<(sizeof(_Src) == sizeof(_Dst))>::_Ret _SameSize;
361 
362 #if !defined (__BORLANDC__) || (__BORLANDC__ < 0x564)
363  typedef typename _IsIntegral<_Src>::_Ret _Int1;
364 #else
365  typedef typename _UnQual<_Src>::_Type _UnQuSrc;
366  typedef typename _IsIntegral<_UnQuSrc>::_Ret _Int1;
367 #endif
368  typedef typename _IsIntegral<_Dst>::_Ret _Int2;
370 
371  typedef typename _IsRational<_Src>::_Ret _Rat1;
372  typedef typename _IsRational<_Dst>::_Ret _Rat2;
374 
376 #if !defined (__BORLANDC__) || (__BORLANDC__ >= 0x564)
378 #else
379  typedef typename _IsUnQual<_Dst>::_Ret _UnQualDst;
381 #endif
383 };
384 
385 template <class _Src, class _Dst>
386 struct _TrivialCopy {
388 # if !defined (__BORLANDC__) || (__BORLANDC__ != 0x560)
390 # else
391  typedef typename _UnConstPtr<_Src*>::_Type _UnConstSrc;
393 # endif
397  static _Ret _Answer() { return _Ret(); }
398 };
399 
400 template <class _Src, class _Dst>
401 struct _TrivialUCopy {
403 # if !defined (__BORLANDC__) || (__BORLANDC__ != 0x560)
405 # else
406  typedef typename _UnConstPtr<_Src*>::_Type _UnConstSrc;
408 # endif
412  static _Ret _Answer() { return _Ret(); }
413 };
414 
415 template <class _Tp>
416 struct _DefaultZeroValue {
417  typedef typename _IsIntegral<_Tp>::_Ret _Tr1;
418  typedef typename _IsRational<_Tp>::_Ret _Tr2;
419  typedef typename _IsPtr<_Tp>::_Ret _Tr3;
421 };
422 
423 template <class _Tp>
424 struct _TrivialInit {
425 # if !defined (__BORLANDC__) || (__BORLANDC__ != 0x560)
427 # else
428  typedef typename _UnConstPtr<_Tp*>::_Type _Tp1;
430 # endif
432  typedef typename _Not<_Tr2>::_Ret _Tr3;
433  typedef typename _Land2<_Tr1, _Tr3>::_Ret _Ret;
434  static _Ret _Answer() { return _Ret(); }
435 };
436 
437 #endif /* !_STLP_USE_BOOST_SUPPORT */
438 
439 template <class _Tp>
440 struct _IsPtrType {
441  typedef typename _IsPtr<_Tp>::_Ret _Type;
442  static _Type _Ret() { return _Type(); }
443 };
444 
445 template <class _Tp>
446 struct _IsRefType {
447  typedef typename _IsRef<_Tp>::_Ret _Type;
448  static _Type _Ret() { return _Type();}
449 };
450 
451 template <class _Tp>
453 #if defined (_STLP_USE_BOOST_SUPPORT) && !defined (_STLP_NO_EXTENSIONS)
460 #else
461  typedef const _Tp& const_param_type;
462  typedef _Tp& param_type;
463 #endif
464 };
465 
466 #if !defined (_STLP_USE_BOOST_SUPPORT) && !defined (_STLP_NO_EXTENSIONS) && defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
467 template <class _Tp>
468 struct __call_traits<_Tp&> {
469  typedef _Tp& param_type;
470  typedef const _Tp& const_param_type;
471 };
472 template <class _Tp>
473 struct __call_traits<const _Tp&> {
474  typedef _Tp& param_type;
475  typedef const _Tp& const_param_type;
476 };
477 #endif
478 
479 template <class _Tp1, class _Tp2>
480 struct _BothPtrType {
481  typedef typename _IsPtr<_Tp1>::_Ret _IsPtr1;
482  typedef typename _IsPtr<_Tp2>::_Ret _IsPtr2;
483 
485  static _Ret _Answer() { return _Ret(); }
486 };
487 
488 template <class _Tp1, class _Tp2, class _IsRef1, class _IsRef2>
489 struct _OKToSwap {
492  static _Type _Answer() { return _Type(); }
493 };
494 
495 template <class _Tp1, class _Tp2, class _IsRef1, class _IsRef2>
497 _IsOKToSwap(_Tp1*, _Tp2*, const _IsRef1&, const _IsRef2&)
499 
500 template <class _Src, class _Dst>
502 { return _TrivialCopy<_Src, _Dst>(); }
503 
504 template <class _Src, class _Dst>
506 { return _TrivialUCopy<_Src, _Dst>(); }
507 
508 #if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) || defined (__BORLANDC__) || \
509  defined (__DMC__)
510 struct _NegativeAnswer {
511  typedef __false_type _Ret;
512  static _Ret _Answer() { return _Ret(); }
513 };
514 
515 template <class _Src, class _Dst>
516 inline _NegativeAnswer _UseTrivialCopy(_Src*, const _Dst*)
517 { return _NegativeAnswer(); }
518 
519 template <class _Src, class _Dst>
520 inline _NegativeAnswer _UseTrivialCopy(_Src*, volatile _Dst*)
521 { return _NegativeAnswer(); }
522 
523 template <class _Src, class _Dst>
524 inline _NegativeAnswer _UseTrivialCopy(_Src*, const volatile _Dst*)
525 { return _NegativeAnswer(); }
526 
527 template <class _Src, class _Dst>
528 inline _NegativeAnswer _UseTrivialUCopy(_Src*, const _Dst*)
529 { return _NegativeAnswer(); }
530 
531 template <class _Src, class _Dst>
532 inline _NegativeAnswer _UseTrivialUCopy(_Src*, volatile _Dst*)
533 { return _NegativeAnswer(); }
534 
535 template <class _Src, class _Dst>
536 inline _NegativeAnswer _UseTrivialUCopy(_Src*, const volatile _Dst*)
537 { return _NegativeAnswer(); }
538 #endif
539 
540 template <class _Tp>
542 { return _TrivialInit<_Tp>(); }
543 
544 template <class _Tp>
545 struct _IsPOD {
547  static _Type _Answer() { return _Type(); }
548 };
549 
550 template <class _Tp>
551 inline _IsPOD<_Tp> _Is_POD(_Tp*)
552 { return _IsPOD<_Tp>(); }
553 
554 template <class _Tp>
557  static _Ret _Answer() { return _Ret(); }
558 };
559 
560 template <class _Tp>
562 { return _DefaultZeroValueQuestion<_Tp>(); }
563 
564 /*
565  * Base class used:
566  * - to simulate partial template specialization
567  * - to simulate partial function ordering
568  * - to recognize STLport class from user specialized one
569  */
570 template <class _Tp>
572 { typedef _Tp _Type; };
573 
574 template <class _Tp>
577 #if defined (__BORLANDC__)
579 #endif
580 };
581 
582 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
583 template <class _Tp>
584 struct _SwapImplemented {
585  typedef typename _IsSTLportClass<_Tp>::_Ret _Ret;
586 # if defined (__BORLANDC__)
587  enum { _Is = _IsSTLportClass<_Tp>::_Is };
588 # endif
589 };
590 #endif
591 
592 template <class _Tp>
593 class _TpWithState : private _Tp {
594  _TpWithState();
595  int _state;
596 };
597 
598 /* This is an internal helper struct used to guess if we are working
599  * on a stateless class. It can only be instanciated with a class type. */
600 template <class _Tp>
601 struct _IsStateless {
602  enum { _Is = sizeof(_TpWithState<_Tp>) == sizeof(int) };
603  typedef typename __bool2type<_Is>::_Ret _Ret;
604 };
605 
607 
608 #ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION
609 # if defined (__BORLANDC__) || \
610  defined (__SUNPRO_CC) || \
611  (defined (__MWERKS__) && (__MWERKS__ <= 0x2303)) || \
612  (defined (__sgi) && defined (_COMPILER_VERSION)) || \
613  defined (__DMC__)
614 # define _STLP_IS_POD_ITER(_It, _Tp) __type_traits< typename iterator_traits< _Tp >::value_type >::is_POD_type()
615 # else
616 # define _STLP_IS_POD_ITER(_It, _Tp) typename __type_traits< typename iterator_traits< _Tp >::value_type >::is_POD_type()
617 # endif
618 #else
619 # define _STLP_IS_POD_ITER(_It, _Tp) _Is_POD( _STLP_VALUE_TYPE( _It, _Tp ) )._Answer()
620 #endif
621 
622 #endif /* _STLP_TYPE_TRAITS_H */
623 
624 // Local Variables:
625 // mode:C++
626 // End:
__false_type _Ret
Definition: type_traits.h:80
_IsCVConvertibleIf< _BothPtrs, _Src, _Dst >::_Ret _Convertible
Definition: type_traits.h:357
_AreSameTypes< _Tp1, _Tp2 >::_Ret _Same
Definition: type_traits.h:490
_IsPtr< _Tp >::_Ret _Tr3
Definition: type_traits.h:419
__false_type _Ret
Definition: type_traits.h:130
const _Tp & const_param_type
Definition: type_traits.h:461
_Land2< _Tr1, _Tr2 >::_Ret _UserRet
Definition: type_traits.h:395
__false_type has_trivial_copy_constructor
Definition: type_traits.h:147
__true_type has_trivial_assignment_operator
Definition: type_traits.h:166
#define _STLP_DEFINE_TYPE_TRAITS_FOR(Type)
Definition: type_traits.h:273
_OKToSwap< _Tp1, _Tp2, _IsRef1, _IsRef2 > _IsOKToSwap(_Tp1 *, _Tp2 *, const _IsRef1 &, const _IsRef2 &)
Definition: type_traits.h:497
_TrivialNativeTypeCopy< _Src, _Dst >::_Ret _NativeRet
Definition: type_traits.h:387
__false_type has_trivial_assignment_operator
Definition: type_traits.h:157
_Land2< _BothPtrs, _Convertible >::_Ret _Trivial1
Definition: type_traits.h:358
__bool2type< pod >::_Ret is_POD_type
__false_type is_POD_type
Definition: type_traits.h:247
_IsPtr< _Src >::_Ret _Ptr1
Definition: type_traits.h:354
__type_traits< _Src >::has_trivial_copy_constructor _Tr1
Definition: type_traits.h:404
_IsPtr< _Tp >::_Ret _Type
Definition: type_traits.h:441
_Lor3< _Tr1, _Tr2, _Tr3 >::_Ret _Ret
Definition: type_traits.h:420
static _Type _Answer()
Definition: type_traits.h:492
_Lor2< _Trivial1, _Trivial2 >::_Ret _Ret
Definition: type_traits.h:382
__false_type has_trivial_destructor
Definition: type_traits.h:246
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
_IsRef< _Tp >::_Ret _Type
Definition: type_traits.h:447
__true_type _Ret
Definition: type_traits.h:84
__false_type is_POD_type
Definition: type_traits.h:150
_DefaultZeroValueQuestion< _Tp > _HasDefaultZeroValue(_Tp *)
Definition: type_traits.h:561
_Lor2< _NativeRet, _UserRet >::_Ret _Ret
Definition: type_traits.h:396
_Land2< _Rat1, _Rat2 >::_Ret _BothRats
Definition: type_traits.h:373
__false_type _Ret
Definition: type_traits.h:173
_IsIntegral< _Src >::_Ret _Int1
Definition: type_traits.h:363
__true_type this_dummy_member_must_be_first
Definition: type_traits.h:225
__false_type _Ret
Definition: type_traits.h:348
#define signed
Definition: prototyp.h:114
_Lor2< _BoostTrivialInit, _STLPTrivialInit >::_Ret _Tr1
_AreCopyable< _Src, _Dst >::_Ret _Tr2
Definition: type_traits.h:394
_IsPtr< _Tp1 >::_Ret _IsPtr1
Definition: type_traits.h:481
unsigned short(__cdecl typeof(TIFFCurrentDirectory))(struct tiff *)
Definition: typeof.h:93
__false_type has_trivial_default_constructor
Definition: type_traits.h:146
static _Ret _Answer()
Definition: type_traits.h:434
__type_traits< _Tp >::is_POD_type _Type
Definition: type_traits.h:546
_TrivialUCopy< _Src, _Dst > _UseTrivialUCopy(_Src *, _Dst *)
Definition: type_traits.h:505
__false_type has_trivial_default_constructor
Definition: type_traits.h:243
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:80
__true_type _Ret
Definition: type_traits.h:88
__type_traits< _Src >::has_trivial_assignment_operator _Tr1
Definition: type_traits.h:389
static _Type _Ret()
Definition: type_traits.h:442
__type_traits< _Tp >::has_trivial_default_constructor _Tr1
Definition: type_traits.h:426
unsigned char
Definition: typeof.h:29
#define _STLP_LONG_LONG
Definition: _apcc.h:12
static _Ret _Answer()
Definition: type_traits.h:412
unsigned short wchar_t
Definition: crtdefs.h:324
_AreCopyable< _Src, _Dst >::_Ret _Tr2
Definition: type_traits.h:409
_Land2< _Ptr1, _Ptr2 >::_Ret _BothPtrs
Definition: type_traits.h:356
typedef bool(CARDLIBPROC *pCanDragProc)(CardRegion &stackobj
_IsRational< _Tp >::_Ret _Tr2
Definition: type_traits.h:418
_Land2< _Tr1, _Tr3 >::_Ret _Ret
Definition: type_traits.h:433
__false_type has_trivial_assignment_operator
Definition: type_traits.h:148
_IsIntegral< _Tp >::_Ret _Tr1
Definition: type_traits.h:417
__false_type _Ret
Definition: type_traits.h:220
__true_type _Ret
Definition: type_traits.h:116
static _Type _Answer()
Definition: type_traits.h:547
unsigned long
Definition: typeof.h:101
__bool2type< trivial_constructor >::_Ret has_trivial_default_constructor
_DefaultZeroValue< _Tp >::_Ret _Tr2
Definition: type_traits.h:431
_IsIntegral< _Dst >::_Ret _Int2
Definition: type_traits.h:368
__true_type has_trivial_default_constructor
Definition: type_traits.h:164
static _Ret _Answer()
Definition: type_traits.h:485
_IsRational< _Src >::_Ret _Rat1
Definition: type_traits.h:371
_DefaultZeroValue< _Tp >::_Ret _Ret
Definition: type_traits.h:556
#define _STLP_TEMPLATE
Definition: features.h:616
_TrivialCopy< _Src, _Dst > _UseTrivialCopy(_Src *, _Dst *)
Definition: type_traits.h:501
__false_type has_trivial_assignment_operator
Definition: type_traits.h:245
static _Ret _Answer()
Definition: type_traits.h:397
#define _STLP_TEMPLATE_NULL
Definition: features.h:652
_Land2< _Int1, _Int2 >::_Ret _BothInts
Definition: type_traits.h:369
__bool2type< is_integral >::_Ret _Ret
_IsPtr< _Dst >::_Ret _Ptr2
Definition: type_traits.h:355
_TrivialInit< _Tp > _UseTrivialInit(_Tp *)
Definition: type_traits.h:541
__false_type has_trivial_copy_constructor
Definition: type_traits.h:244
__bool2type< is_pointer >::_Ret _Ret
__bool2type< _Is >::_Ret _Ret
Definition: type_traits.h:603
_Land2< _BothNatives, _SameSize >::_Ret _Trivial2
Definition: type_traits.h:377
_Tp & param_type
Definition: type_traits.h:462
_IsConvertible< _Tp, __stlport_class< _Tp > >::_Ret _Ret
Definition: type_traits.h:576
_Not< _Tr2 >::_Ret _Tr3
Definition: type_traits.h:432
_TrivialNativeTypeCopy< _Src, _Dst >::_Ret _NativeRet
Definition: type_traits.h:402
_IsRational< _Dst >::_Ret _Rat2
Definition: type_traits.h:372
__bool2type< trivial_assign >::_Ret has_trivial_assignment_operator
__true_type _Ret
Definition: type_traits.h:110
#define _STLP_END_NAMESPACE
Definition: features.h:503
_Land2< _IsPtr1, _IsPtr2 >::_Ret _Ret
Definition: type_traits.h:484
__bool2type< trivial_copy >::_Ret has_trivial_copy_constructor
_IsPtr< _Tp2 >::_Ret _IsPtr2
Definition: type_traits.h:482
static _Type _Ret()
Definition: type_traits.h:448
_IsPOD< _Tp > _Is_POD(_Tp *)
Definition: type_traits.h:551
#define const
Definition: zconf.h:230
#define _STLP_BEGIN_NAMESPACE
Definition: features.h:501
_Lor2< _NativeRet, _UserRet >::_Ret _Ret
Definition: type_traits.h:411
_Land3< _Same, _IsRef1, _IsRef2 >::_Ret _Type
Definition: type_traits.h:491
#define _STLP_CALL
Definition: _bc.h:131
__false_type has_trivial_default_constructor
Definition: type_traits.h:155
__bool2type< trivial_destructor >::_Ret has_trivial_destructor
__false_type has_trivial_destructor
Definition: type_traits.h:149
_Lor2< _BothInts, _BothRats >::_Ret _BothNatives
Definition: type_traits.h:375
__bool2type< _Is >::_Ret _Ret
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
_Land2< _Tr1, _Tr2 >::_Ret _UserRet
Definition: type_traits.h:410