ReactOS 0.4.15-dev-7897-g78dc504
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/*
27This header file provides a framework for allowing compile time dispatch
28based on type attributes. This is useful when writing template code.
29For example, when making a copy of an array of an unknown type, it helps
30to know if the type has a trivial copy constructor or not, to help decide
31if a memcpy can be used.
32
33The class template __type_traits provides a series of typedefs each of
34which is either __true_type or __false_type. The argument to
35__type_traits can be any type. The typedefs within this template will
36attain 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
44EXAMPLE:
45
46//Copy an array of elements which have non-trivial copy constructors
47template <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.
49template <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
52template <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
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
79template <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
129template <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.
144template <class _Tp> struct __type_traits;
145template <class _IsPOD> struct __type_traits_aux {
151};
152
160};
161
169};
170
171template <class _Tp>
172struct _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
185struct _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
196char _STLP_CALL _IsP(bool, _PointerShim); // no implementation is required
197char* _STLP_CALL _IsP(bool, ...); // no implementation is required
198
199template <class _Tp>
200struct _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.
214template <class _Tp>
215struct __type_traits : __type_traits_aux<typename _IsPtr<_Tp>::_Ret> {};
216
217# else /* _STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS */
218
219template <class _Tp> struct _IsPtr {
221};
222
223template <class _Tp>
224struct __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)
258template <class _Tp> struct _IsPtr<_Tp*>
259{ typedef __true_type _Ret; };
260template <class _Tp> struct _IsRef<_Tp&>
261{ typedef __true_type _Ret; };
262
263template <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
289# endif
291# if defined ( _STLP_HAS_WCHAR_T ) && ! defined (_STLP_WCHAR_T_IS_USHORT)
293# endif /* _STLP_HAS_WCHAR_T */
294
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 )
312# endif
313
314# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
315template <class _ArePtrs, class _Src, class _Dst>
317{ typedef typename _IsCVConvertible<_Src, _Dst>::_Ret _Ret; };
318
319template <class _Src, class _Dst>
320struct _IsCVConvertibleIf<__false_type, _Src, _Dst>
321{ typedef __false_type _Ret; };
322# else
323# if defined (_STLP_MEMBER_TEMPLATE_CLASSES)
324template <class _ArePtrs>
325struct _IsCVConvertibleIfAux {
326 template <class _Src, class _Dst>
327 struct _In
328 { typedef typename _IsCVConvertible<_Src, _Dst>::_Ret _Ret; };
329};
330
332struct _IsCVConvertibleIfAux<__false_type> {
333 template <class _Src, class _Dst>
334 struct _In
335 { typedef __false_type _Ret; };
336};
337
338template <class _ArePtrs, class _Src, class _Dst>
339struct _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 */
346template <class _ArePtrs, class _Src, class _Dst>
348{ typedef __false_type _Ret; };
349# endif
350# endif
351
352template <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)
364#else
365 typedef typename _UnQual<_Src>::_Type _UnQuSrc;
366 typedef typename _IsIntegral<_UnQuSrc>::_Ret _Int1;
367#endif
370
374
376#if !defined (__BORLANDC__) || (__BORLANDC__ >= 0x564)
378#else
379 typedef typename _IsUnQual<_Dst>::_Ret _UnQualDst;
381#endif
383};
384
385template <class _Src, class _Dst>
386struct _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
400template <class _Src, class _Dst>
401struct _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
415template <class _Tp>
416struct _DefaultZeroValue {
417 typedef typename _IsIntegral<_Tp>::_Ret _Tr1;
418 typedef typename _IsRational<_Tp>::_Ret _Tr2;
419 typedef typename _IsPtr<_Tp>::_Ret _Tr3;
421};
422
423template <class _Tp>
424struct _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;
434 static _Ret _Answer() { return _Ret(); }
435};
436
437#endif /* !_STLP_USE_BOOST_SUPPORT */
438
439template <class _Tp>
441 typedef typename _IsPtr<_Tp>::_Ret _Type;
442 static _Type _Ret() { return _Type(); }
443};
444
445template <class _Tp>
447 typedef typename _IsRef<_Tp>::_Ret _Type;
448 static _Type _Ret() { return _Type();}
449};
450
451template <class _Tp>
453#if defined (_STLP_USE_BOOST_SUPPORT) && !defined (_STLP_NO_EXTENSIONS)
455 typename ::boost::add_const<_Tp>::type,
456 typename ::boost::add_reference< typename ::boost::add_const<_Tp>::type >::type>::_Ret const_param_type;
458 typename ::boost::remove_const<_Tp>::type,
459 typename ::boost::add_reference<_Tp>::type>::_Ret param_type;
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)
467template <class _Tp>
468struct __call_traits<_Tp&> {
469 typedef _Tp& param_type;
470 typedef const _Tp& const_param_type;
471};
472template <class _Tp>
473struct __call_traits<const _Tp&> {
474 typedef _Tp& param_type;
475 typedef const _Tp& const_param_type;
476};
477#endif
478
479template <class _Tp1, class _Tp2>
481 typedef typename _IsPtr<_Tp1>::_Ret _IsPtr1;
482 typedef typename _IsPtr<_Tp2>::_Ret _IsPtr2;
483
485 static _Ret _Answer() { return _Ret(); }
486};
487
488template <class _Tp1, class _Tp2, class _IsRef1, class _IsRef2>
489struct _OKToSwap {
492 static _Type _Answer() { return _Type(); }
493};
494
495template <class _Tp1, class _Tp2, class _IsRef1, class _IsRef2>
497_IsOKToSwap(_Tp1*, _Tp2*, const _IsRef1&, const _IsRef2&)
499
500template <class _Src, class _Dst>
502{ return _TrivialCopy<_Src, _Dst>(); }
503
504template <class _Src, class _Dst>
506{ return _TrivialUCopy<_Src, _Dst>(); }
507
508#if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) || defined (__BORLANDC__) || \
509 defined (__DMC__)
510struct _NegativeAnswer {
511 typedef __false_type _Ret;
512 static _Ret _Answer() { return _Ret(); }
513};
514
515template <class _Src, class _Dst>
516inline _NegativeAnswer _UseTrivialCopy(_Src*, const _Dst*)
517{ return _NegativeAnswer(); }
518
519template <class _Src, class _Dst>
520inline _NegativeAnswer _UseTrivialCopy(_Src*, volatile _Dst*)
521{ return _NegativeAnswer(); }
522
523template <class _Src, class _Dst>
524inline _NegativeAnswer _UseTrivialCopy(_Src*, const volatile _Dst*)
525{ return _NegativeAnswer(); }
526
527template <class _Src, class _Dst>
528inline _NegativeAnswer _UseTrivialUCopy(_Src*, const _Dst*)
529{ return _NegativeAnswer(); }
530
531template <class _Src, class _Dst>
532inline _NegativeAnswer _UseTrivialUCopy(_Src*, volatile _Dst*)
533{ return _NegativeAnswer(); }
534
535template <class _Src, class _Dst>
536inline _NegativeAnswer _UseTrivialUCopy(_Src*, const volatile _Dst*)
537{ return _NegativeAnswer(); }
538#endif
539
540template <class _Tp>
542{ return _TrivialInit<_Tp>(); }
543
544template <class _Tp>
545struct _IsPOD {
547 static _Type _Answer() { return _Type(); }
548};
549
550template <class _Tp>
552{ return _IsPOD<_Tp>(); }
553
554template <class _Tp>
557 static _Ret _Answer() { return _Ret(); }
558};
559
560template <class _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 */
570template <class _Tp>
572{ typedef _Tp _Type; };
573
574template <class _Tp>
577#if defined (__BORLANDC__)
579#endif
580};
581
582#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
583template <class _Tp>
584struct _SwapImplemented {
585 typedef typename _IsSTLportClass<_Tp>::_Ret _Ret;
586# if defined (__BORLANDC__)
587 enum { _Is = _IsSTLportClass<_Tp>::_Is };
588# endif
589};
590#endif
591
592template <class _Tp>
593class _TpWithState : private _Tp {
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. */
600template <class _Tp>
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:
#define _STLP_LONG_LONG
Definition: _apcc.h:12
#define _STLP_CALL
Definition: _bc.h:131
unsigned short wchar_t
Definition: crtdefs.h:345
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
unsigned char
Definition: typeof.h:29
unsigned long
Definition: typeof.h:102
unsigned short(__cdecl typeof(TIFFCurrentDirectory))(struct tiff *)
Definition: typeof.h:94
#define _STLP_TEMPLATE_NULL
Definition: features.h:652
#define _STLP_BEGIN_NAMESPACE
Definition: features.h:501
#define _STLP_END_NAMESPACE
Definition: features.h:503
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:80
static unsigned(__cdecl *hash_bstr)(bstr_t s)
static float(__cdecl *square_half_float)(float x
#define bool
Definition: nsiface.idl:72
#define signed
Definition: prototyp.h:114
_IsPtr< _Tp1 >::_Ret _IsPtr1
Definition: type_traits.h:481
_IsPtr< _Tp2 >::_Ret _IsPtr2
Definition: type_traits.h:482
_Land2< _IsPtr1, _IsPtr2 >::_Ret _Ret
Definition: type_traits.h:484
static _Ret _Answer()
Definition: type_traits.h:485
_DefaultZeroValue< _Tp >::_Ret _Ret
Definition: type_traits.h:556
_Lor3< _Tr1, _Tr2, _Tr3 >::_Ret _Ret
Definition: type_traits.h:420
_IsIntegral< _Tp >::_Ret _Tr1
Definition: type_traits.h:417
_IsRational< _Tp >::_Ret _Tr2
Definition: type_traits.h:418
_IsPtr< _Tp >::_Ret _Tr3
Definition: type_traits.h:419
__false_type _Ret
Definition: type_traits.h:348
__true_type _Ret
Definition: type_traits.h:84
__true_type _Ret
Definition: type_traits.h:88
__true_type _Ret
Definition: type_traits.h:110
__true_type _Ret
Definition: type_traits.h:116
__bool2type< is_integral >::_Ret _Ret
__false_type _Ret
Definition: type_traits.h:80
__type_traits< _Tp >::is_POD_type _Type
Definition: type_traits.h:546
static _Type _Answer()
Definition: type_traits.h:547
static _Type _Ret()
Definition: type_traits.h:442
_IsPtr< _Tp >::_Ret _Type
Definition: type_traits.h:441
__false_type _Ret
Definition: type_traits.h:220
__bool2type< is_pointer >::_Ret _Ret
__false_type _Ret
Definition: type_traits.h:130
_IsRef< _Tp >::_Ret _Type
Definition: type_traits.h:447
static _Type _Ret()
Definition: type_traits.h:448
__false_type _Ret
Definition: type_traits.h:173
__bool2type< _Is >::_Ret _Ret
_IsConvertible< _Tp, __stlport_class< _Tp > >::_Ret _Ret
Definition: type_traits.h:576
__bool2type< _Is >::_Ret _Ret
Definition: type_traits.h:603
_AreSameTypes< _Tp1, _Tp2 >::_Ret _Same
Definition: type_traits.h:490
static _Type _Answer()
Definition: type_traits.h:492
_Land3< _Same, _IsRef1, _IsRef2 >::_Ret _Type
Definition: type_traits.h:491
__type_traits< _Src >::has_trivial_assignment_operator _Tr1
Definition: type_traits.h:389
static _Ret _Answer()
Definition: type_traits.h:397
_Land2< _Tr1, _Tr2 >::_Ret _UserRet
Definition: type_traits.h:395
_AreCopyable< _Src, _Dst >::_Ret _Tr2
Definition: type_traits.h:394
_TrivialNativeTypeCopy< _Src, _Dst >::_Ret _NativeRet
Definition: type_traits.h:387
_Lor2< _NativeRet, _UserRet >::_Ret _Ret
Definition: type_traits.h:396
_Lor2< _BoostTrivialInit, _STLPTrivialInit >::_Ret _Tr1
_DefaultZeroValue< _Tp >::_Ret _Tr2
Definition: type_traits.h:431
__type_traits< _Tp >::has_trivial_default_constructor _Tr1
Definition: type_traits.h:426
_Land2< _Tr1, _Tr3 >::_Ret _Ret
Definition: type_traits.h:433
_Not< _Tr2 >::_Ret _Tr3
Definition: type_traits.h:432
static _Ret _Answer()
Definition: type_traits.h:434
_Lor2< _BothInts, _BothRats >::_Ret _BothNatives
Definition: type_traits.h:375
_Land2< _Int1, _Int2 >::_Ret _BothInts
Definition: type_traits.h:369
_IsIntegral< _Src >::_Ret _Int1
Definition: type_traits.h:363
_Land2< _BothPtrs, _Convertible >::_Ret _Trivial1
Definition: type_traits.h:358
_Land2< _Rat1, _Rat2 >::_Ret _BothRats
Definition: type_traits.h:373
_IsPtr< _Src >::_Ret _Ptr1
Definition: type_traits.h:354
_Land2< _BothNatives, _SameSize >::_Ret _Trivial2
Definition: type_traits.h:377
_Land2< _Ptr1, _Ptr2 >::_Ret _BothPtrs
Definition: type_traits.h:356
_Lor2< _Trivial1, _Trivial2 >::_Ret _Ret
Definition: type_traits.h:382
_IsRational< _Dst >::_Ret _Rat2
Definition: type_traits.h:372
_IsIntegral< _Dst >::_Ret _Int2
Definition: type_traits.h:368
_IsRational< _Src >::_Ret _Rat1
Definition: type_traits.h:371
_IsCVConvertibleIf< _BothPtrs, _Src, _Dst >::_Ret _Convertible
Definition: type_traits.h:357
_IsPtr< _Dst >::_Ret _Ptr2
Definition: type_traits.h:355
_Lor2< _NativeRet, _UserRet >::_Ret _Ret
Definition: type_traits.h:411
static _Ret _Answer()
Definition: type_traits.h:412
__type_traits< _Src >::has_trivial_copy_constructor _Tr1
Definition: type_traits.h:404
_AreCopyable< _Src, _Dst >::_Ret _Tr2
Definition: type_traits.h:409
_Land2< _Tr1, _Tr2 >::_Ret _UserRet
Definition: type_traits.h:410
_TrivialNativeTypeCopy< _Src, _Dst >::_Ret _NativeRet
Definition: type_traits.h:402
_Tp & param_type
Definition: type_traits.h:462
const _Tp & const_param_type
Definition: type_traits.h:461
__false_type has_trivial_default_constructor
Definition: type_traits.h:155
__false_type has_trivial_assignment_operator
Definition: type_traits.h:157
__true_type has_trivial_default_constructor
Definition: type_traits.h:164
__true_type has_trivial_assignment_operator
Definition: type_traits.h:166
__false_type is_POD_type
Definition: type_traits.h:150
__false_type has_trivial_assignment_operator
Definition: type_traits.h:148
__false_type has_trivial_default_constructor
Definition: type_traits.h:146
__false_type has_trivial_destructor
Definition: type_traits.h:149
__false_type has_trivial_copy_constructor
Definition: type_traits.h:147
__false_type is_POD_type
Definition: type_traits.h:247
__bool2type< pod >::_Ret is_POD_type
__bool2type< trivial_destructor >::_Ret has_trivial_destructor
__false_type has_trivial_assignment_operator
Definition: type_traits.h:245
__false_type has_trivial_destructor
Definition: type_traits.h:246
__bool2type< trivial_constructor >::_Ret has_trivial_default_constructor
__false_type has_trivial_copy_constructor
Definition: type_traits.h:244
__bool2type< trivial_copy >::_Ret has_trivial_copy_constructor
__false_type has_trivial_default_constructor
Definition: type_traits.h:243
__bool2type< trivial_assign >::_Ret has_trivial_assignment_operator
__true_type this_dummy_member_must_be_first
Definition: type_traits.h:225
#define _STLP_DEFINE_TYPE_TRAITS_FOR(Type)
Definition: type_traits.h:273
_DefaultZeroValueQuestion< _Tp > _HasDefaultZeroValue(_Tp *)
Definition: type_traits.h:561
_OKToSwap< _Tp1, _Tp2, _IsRef1, _IsRef2 > _IsOKToSwap(_Tp1 *, _Tp2 *, const _IsRef1 &, const _IsRef2 &)
Definition: type_traits.h:497
_IsPOD< _Tp > _Is_POD(_Tp *)
Definition: type_traits.h:551
_TrivialInit< _Tp > _UseTrivialInit(_Tp *)
Definition: type_traits.h:541
_TrivialUCopy< _Src, _Dst > _UseTrivialUCopy(_Src *, _Dst *)
Definition: type_traits.h:505
_TrivialCopy< _Src, _Dst > _UseTrivialCopy(_Src *, _Dst *)
Definition: type_traits.h:501
Definition: pdh_main.c:94
#define const
Definition: zconf.h:233