ReactOS  0.4.13-dev-249-gcba1a2f
type_manips.h
Go to the documentation of this file.
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 
22 
23 struct __true_type {};
24 struct __false_type {};
25 
26 #if defined (_STLP_USE_NAMESPACES) && !defined (_STLP_DONT_USE_PRIV_NAMESPACE)
28 using _STLP_STD::__true_type;
29 using _STLP_STD::__false_type;
31 #endif
32 
33 //bool to type
34 template <int _Is>
36 { typedef __true_type _Ret; };
37 
39 struct __bool2type<1> { typedef __true_type _Ret; };
40 
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 
49 struct __type2bool<__true_type> { enum {_Ret = 1}; };
50 
52 struct __type2bool<__false_type> { enum {_Ret = 0}; };
53 
54 //Negation
55 template <class _BoolType>
56 struct _Not { typedef __false_type _Ret; };
57 
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 
67 
68 // logical and of 3 predicated
69 template <class _P1, class _P2, class _P3>
70 struct _Land3 { typedef __false_type _Ret; };
71 
74 
75 //logical or of 2 predicated
76 template <class _P1, class _P2>
77 struct _Lor2 { typedef __true_type _Ret; };
78 
81 
82 // logical or of 3 predicated
83 template <class _P1, class _P2, class _P3>
84 struct _Lor3 { typedef __true_type _Ret; };
85 
88 
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.
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 
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__)
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 {
206 };
207 
208 template <class _Tp1, class _Tp2>
210  enum { _Same = 0 };
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>
225  static char _Test(bool, _Dst);
226  static char* _Test(bool, ...);
227  static _Src _MakeSource();
228 };
229 
230 template <class _Src, class _Dst>
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>
294 # if !defined (__BORLANDC__) || (__BORLANDC__ >= 0x590)
296  enum { value = (sizeof(char) == sizeof(_H::_Test(false, _H::_MakeSource()))) };
297 # else
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 
320 
321 #endif /* _STLP_TYPE_MANIPS_H */
__true_type _Ret
Definition: type_manips.h:39
_NoVolatilePointerShim(const void *)
__true_type _Ret
Definition: type_manips.h:36
__true_type _Ret
Definition: type_manips.h:84
#define _STLP_MOVE_TO_PRIV_NAMESPACE
Definition: features.h:524
static char _Test(bool, _Dst)
__bool2type< _Ret >::_Ret _RetT
Definition: type_manips.h:174
__false_type _Ret
Definition: type_manips.h:63
static _Dst * __null_dst()
_Tp2 _Ret
Definition: type_manips.h:150
unsigned char
Definition: typeof.h:29
__false_type _Ret
Definition: type_manips.h:70
__true_type _Ret
Definition: type_manips.h:59
#define volatile
Definition: prototyp.h:117
#define _STLP_MOVE_TO_STD_NAMESPACE
Definition: features.h:525
__bool2type< value >::_Ret _Ret
Definition: type_manips.h:302
static _Src _MakeSource()
char _STLP_CALL _IsCopyableFun(bool, _NoVolatilePointerShim, _Tp const *, _Tp *)
#define false
Definition: stdbool.h:38
__false_type _Ret
Definition: type_manips.h:211
_Copyable< _Src, _Dst >::_RetT _Ret
Definition: type_manips.h:205
_ConversionHelper< _Src *, const volatile _Dst * > _H
Definition: type_manips.h:232
#define _STLP_TEMPLATE
Definition: features.h:616
#define _STLP_TEMPLATE_NULL
Definition: features.h:652
#define _STLP_END_NAMESPACE
Definition: features.h:503
_ConversionHelper< _Src, _Dst > _H
Definition: type_manips.h:295
__true_type _Ret
Definition: type_manips.h:77
static _Src * __null_src()
__false_type _Ret
Definition: type_manips.h:56
#define const
Definition: zconf.h:230
__false_type _Ret
Definition: type_manips.h:42
#define _STLP_BEGIN_NAMESPACE
Definition: features.h:501
__bool2type< value >::_Ret _Ret
Definition: type_manips.h:234
#define _STLP_CALL
Definition: _bc.h:131