All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Size.h
Go to the documentation of this file.
1 //=================================================================================================
20 //=================================================================================================
21 
22 #ifndef _BLAZE_UTIL_CONSTRAINTS_SIZE_H_
23 #define _BLAZE_UTIL_CONSTRAINTS_SIZE_H_
24 
25 
26 //*************************************************************************************************
27 // Includes
28 //*************************************************************************************************
29 
31 #include <blaze/util/Suffix.h>
33 
34 
35 namespace blaze {
36 
37 //=================================================================================================
38 //
39 // MUST_HAVE_SIZE CONSTRAINT
40 //
41 //=================================================================================================
42 
43 //*************************************************************************************************
53 template< bool > struct CONSTRAINT_MUST_HAVE_SIZE_FAILED;
54 template<> struct CONSTRAINT_MUST_HAVE_SIZE_FAILED<true> { enum { value = 1 }; };
56 //*************************************************************************************************
57 
58 
59 //*************************************************************************************************
65 #define BLAZE_CONSTRAINT_MUST_HAVE_SIZE(T,S) \
66  typedef \
67  ::blaze::CONSTRAINT_TEST< \
68  ::blaze::CONSTRAINT_MUST_HAVE_SIZE_FAILED< ::blaze::HasSize<T,S>::value >::value > \
69  BLAZE_JOIN( CONSTRAINT_MUST_HAVE_SIZE_TYPEDEF, __LINE__ )
70 //*************************************************************************************************
71 
72 
73 
74 
75 //=================================================================================================
76 //
77 // MUST_NOT_HAVE_SIZE CONSTRAINT
78 //
79 //=================================================================================================
80 
81 //*************************************************************************************************
91 template< bool > struct CONSTRAINT_MUST_NOT_HAVE_SIZE_FAILED;
92 template<> struct CONSTRAINT_MUST_NOT_HAVE_SIZE_FAILED<true> { enum { value = 1 }; };
94 //*************************************************************************************************
95 
96 
97 //*************************************************************************************************
103 #define BLAZE_CONSTRAINT_MUST_NOT_HAVE_SIZE(T,S) \
104  typedef \
105  ::blaze::CONSTRAINT_TEST< \
106  ::blaze::CONSTRAINT_MUST_NOT_HAVE_SIZE_FAILED< !::blaze::HasSize<T,S>::value >::value > \
107  BLAZE_JOIN( CONSTRAINT_MUST_NOT_HAVE_SIZE_TYPEDEF, __LINE__ )
108 //*************************************************************************************************
109 
110 
111 
112 
113 //=================================================================================================
114 //
115 // MUST_HAVE_1_BYTE CONSTRAINT
116 //
117 //=================================================================================================
118 
119 //*************************************************************************************************
129 template< bool > struct CONSTRAINT_MUST_HAVE_1_BYTE_FAILED;
130 template<> struct CONSTRAINT_MUST_HAVE_1_BYTE_FAILED<true> { enum { value = 1 }; };
132 //*************************************************************************************************
133 
134 
135 //*************************************************************************************************
141 #define BLAZE_CONSTRAINT_MUST_HAVE_1_BYTE(T) \
142  typedef \
143  ::blaze::CONSTRAINT_TEST< \
144  ::blaze::CONSTRAINT_MUST_HAVE_1_BYTE_FAILED< ::blaze::Has1Byte<T>::value >::value > \
145  BLAZE_JOIN( CONSTRAINT_MUST_HAVE_1_BYTE_TYPEDEF, __LINE__ )
146 //*************************************************************************************************
147 
148 
149 
150 
151 //=================================================================================================
152 //
153 // MUST_NOT_HAVE_1_BYTE CONSTRAINT
154 //
155 //=================================================================================================
156 
157 //*************************************************************************************************
167 template< bool > struct CONSTRAINT_MUST_NOT_HAVE_1_BYTE_FAILED;
168 template<> struct CONSTRAINT_MUST_NOT_HAVE_1_BYTE_FAILED<true> { enum { value = 1 }; };
170 //*************************************************************************************************
171 
172 
173 //*************************************************************************************************
179 #define BLAZE_CONSTRAINT_MUST_NOT_HAVE_1_BYTE(T) \
180  typedef \
181  ::blaze::CONSTRAINT_TEST< \
182  ::blaze::CONSTRAINT_MUST_NOT_HAVE_1_BYTE_FAILED< !::blaze::Has1Byte<T>::value >::value > \
183  BLAZE_JOIN( CONSTRAINT_MUST_NOT_HAVE_1_BYTE_TYPEDEF, __LINE__ )
184 //*************************************************************************************************
185 
186 
187 
188 
189 //=================================================================================================
190 //
191 // MUST_HAVE_2_BYTES CONSTRAINT
192 //
193 //=================================================================================================
194 
195 //*************************************************************************************************
205 template< bool > struct CONSTRAINT_MUST_HAVE_2_BYTES_FAILED;
206 template<> struct CONSTRAINT_MUST_HAVE_2_BYTES_FAILED<true> { enum { value = 1 }; };
208 //*************************************************************************************************
209 
210 
211 //*************************************************************************************************
217 #define BLAZE_CONSTRAINT_MUST_HAVE_2_BYTES(T) \
218  typedef \
219  ::blaze::CONSTRAINT_TEST< \
220  ::blaze::CONSTRAINT_MUST_HAVE_2_BYTES_FAILED< ::blaze::Has2Bytes<T>::value >::value > \
221  BLAZE_JOIN( CONSTRAINT_MUST_HAVE_2_BYTES_TYPEDEF, __LINE__ )
222 //*************************************************************************************************
223 
224 
225 
226 
227 //=================================================================================================
228 //
229 // MUST_NOT_HAVE_2_BYTES CONSTRAINT
230 //
231 //=================================================================================================
232 
233 //*************************************************************************************************
243 template< bool > struct CONSTRAINT_MUST_NOT_HAVE_2_BYTES_FAILED;
244 template<> struct CONSTRAINT_MUST_NOT_HAVE_2_BYTES_FAILED<true> { enum { value = 1 }; };
246 //*************************************************************************************************
247 
248 
249 //*************************************************************************************************
255 #define BLAZE_CONSTRAINT_MUST_NOT_HAVE_2_BYTES(T) \
256  typedef \
257  ::blaze::CONSTRAINT_TEST< \
258  ::blaze::CONSTRAINT_MUST_NOT_HAVE_2_BYTES_FAILED< !::blaze::Has2Bytes<T>::value >::value > \
259  BLAZE_JOIN( CONSTRAINT_MUST_NOT_HAVE_2_BYTES_TYPEDEF, __LINE__ )
260 //*************************************************************************************************
261 
262 
263 
264 
265 //=================================================================================================
266 //
267 // MUST_HAVE_4_BYTES CONSTRAINT
268 //
269 //=================================================================================================
270 
271 //*************************************************************************************************
281 template< bool > struct CONSTRAINT_MUST_HAVE_4_BYTES_FAILED;
282 template<> struct CONSTRAINT_MUST_HAVE_4_BYTES_FAILED<true> { enum { value = 1 }; };
284 //*************************************************************************************************
285 
286 
287 //*************************************************************************************************
293 #define BLAZE_CONSTRAINT_MUST_HAVE_4_BYTES(T) \
294  typedef \
295  ::blaze::CONSTRAINT_TEST< \
296  ::blaze::CONSTRAINT_MUST_HAVE_4_BYTES_FAILED< ::blaze::Has4Bytes<T>::value >::value > \
297  BLAZE_JOIN( CONSTRAINT_MUST_HAVE_4_BYTES_TYPEDEF, __LINE__ )
298 //*************************************************************************************************
299 
300 
301 
302 
303 //=================================================================================================
304 //
305 // MUST_NOT_HAVE_4_BYTES CONSTRAINT
306 //
307 //=================================================================================================
308 
309 //*************************************************************************************************
319 template< bool > struct CONSTRAINT_MUST_NOT_HAVE_4_BYTES_FAILED;
320 template<> struct CONSTRAINT_MUST_NOT_HAVE_4_BYTES_FAILED<true> { enum { value = 1 }; };
322 //*************************************************************************************************
323 
324 
325 //*************************************************************************************************
331 #define BLAZE_CONSTRAINT_MUST_NOT_HAVE_4_BYTES(T) \
332  typedef \
333  ::blaze::CONSTRAINT_TEST< \
334  ::blaze::CONSTRAINT_MUST_NOT_HAVE_4_BYTES_FAILED< !::blaze::Has4Bytes<T>::value >::value > \
335  BLAZE_JOIN( CONSTRAINT_MUST_NOT_HAVE_4_BYTES_TYPEDEF, __LINE__ )
336 //*************************************************************************************************
337 
338 
339 
340 
341 //=================================================================================================
342 //
343 // MUST_HAVE_8_BYTES CONSTRAINT
344 //
345 //=================================================================================================
346 
347 //*************************************************************************************************
357 template< bool > struct CONSTRAINT_MUST_HAVE_8_BYTES_FAILED;
358 template<> struct CONSTRAINT_MUST_HAVE_8_BYTES_FAILED<true> { enum { value = 1 }; };
360 //*************************************************************************************************
361 
362 
363 //*************************************************************************************************
369 #define BLAZE_CONSTRAINT_MUST_HAVE_8_BYTES(T) \
370  typedef \
371  ::blaze::CONSTRAINT_TEST< \
372  ::blaze::CONSTRAINT_MUST_HAVE_8_BYTES_FAILED< ::blaze::Has8Bytes<T>::value >::value > \
373  BLAZE_JOIN( CONSTRAINT_MUST_HAVE_8_BYTES_TYPEDEF, __LINE__ )
374 //*************************************************************************************************
375 
376 
377 
378 
379 //=================================================================================================
380 //
381 // MUST_NOT_HAVE_8_BYTES CONSTRAINT
382 //
383 //=================================================================================================
384 
385 //*************************************************************************************************
395 template< bool > struct CONSTRAINT_MUST_NOT_HAVE_8_BYTES_FAILED;
396 template<> struct CONSTRAINT_MUST_NOT_HAVE_8_BYTES_FAILED<true> { enum { value = 1 }; };
398 //*************************************************************************************************
399 
400 
401 //*************************************************************************************************
407 #define BLAZE_CONSTRAINT_MUST_NOT_HAVE_8_BYTES(T) \
408  typedef \
409  ::blaze::CONSTRAINT_TEST< \
410  ::blaze::CONSTRAINT_MUST_NOT_HAVE_8_BYTES_FAILED< !::blaze::Has8Bytes<T>::value >::value > \
411  BLAZE_JOIN( CONSTRAINT_MUST_NOT_HAVE_8_BYTES_TYPEDEF, __LINE__ )
412 //*************************************************************************************************
413 
414 } // namespace blaze
415 
416 #endif