All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Size.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_UTIL_CONSTRAINTS_SIZE_H_
36 #define _BLAZE_UTIL_CONSTRAINTS_SIZE_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
44 #include <blaze/util/Suffix.h>
46 
47 
48 namespace blaze {
49 
50 //=================================================================================================
51 //
52 // MUST_HAVE_SIZE CONSTRAINT
53 //
54 //=================================================================================================
55 
56 //*************************************************************************************************
66 template< bool > struct CONSTRAINT_MUST_HAVE_SIZE_FAILED;
67 template<> struct CONSTRAINT_MUST_HAVE_SIZE_FAILED<true> { enum { value = 1 }; };
69 //*************************************************************************************************
70 
71 
72 //*************************************************************************************************
78 #define BLAZE_CONSTRAINT_MUST_HAVE_SIZE(T,S) \
79  typedef \
80  ::blaze::CONSTRAINT_TEST< \
81  ::blaze::CONSTRAINT_MUST_HAVE_SIZE_FAILED< ::blaze::HasSize<T,S>::value >::value > \
82  BLAZE_JOIN( CONSTRAINT_MUST_HAVE_SIZE_TYPEDEF, __LINE__ )
83 //*************************************************************************************************
84 
85 
86 
87 
88 //=================================================================================================
89 //
90 // MUST_NOT_HAVE_SIZE CONSTRAINT
91 //
92 //=================================================================================================
93 
94 //*************************************************************************************************
104 template< bool > struct CONSTRAINT_MUST_NOT_HAVE_SIZE_FAILED;
105 template<> struct CONSTRAINT_MUST_NOT_HAVE_SIZE_FAILED<true> { enum { value = 1 }; };
107 //*************************************************************************************************
108 
109 
110 //*************************************************************************************************
116 #define BLAZE_CONSTRAINT_MUST_NOT_HAVE_SIZE(T,S) \
117  typedef \
118  ::blaze::CONSTRAINT_TEST< \
119  ::blaze::CONSTRAINT_MUST_NOT_HAVE_SIZE_FAILED< !::blaze::HasSize<T,S>::value >::value > \
120  BLAZE_JOIN( CONSTRAINT_MUST_NOT_HAVE_SIZE_TYPEDEF, __LINE__ )
121 //*************************************************************************************************
122 
123 
124 
125 
126 //=================================================================================================
127 //
128 // MUST_HAVE_1_BYTE CONSTRAINT
129 //
130 //=================================================================================================
131 
132 //*************************************************************************************************
142 template< bool > struct CONSTRAINT_MUST_HAVE_1_BYTE_FAILED;
143 template<> struct CONSTRAINT_MUST_HAVE_1_BYTE_FAILED<true> { enum { value = 1 }; };
145 //*************************************************************************************************
146 
147 
148 //*************************************************************************************************
154 #define BLAZE_CONSTRAINT_MUST_HAVE_1_BYTE(T) \
155  typedef \
156  ::blaze::CONSTRAINT_TEST< \
157  ::blaze::CONSTRAINT_MUST_HAVE_1_BYTE_FAILED< ::blaze::Has1Byte<T>::value >::value > \
158  BLAZE_JOIN( CONSTRAINT_MUST_HAVE_1_BYTE_TYPEDEF, __LINE__ )
159 //*************************************************************************************************
160 
161 
162 
163 
164 //=================================================================================================
165 //
166 // MUST_NOT_HAVE_1_BYTE CONSTRAINT
167 //
168 //=================================================================================================
169 
170 //*************************************************************************************************
180 template< bool > struct CONSTRAINT_MUST_NOT_HAVE_1_BYTE_FAILED;
181 template<> struct CONSTRAINT_MUST_NOT_HAVE_1_BYTE_FAILED<true> { enum { value = 1 }; };
183 //*************************************************************************************************
184 
185 
186 //*************************************************************************************************
192 #define BLAZE_CONSTRAINT_MUST_NOT_HAVE_1_BYTE(T) \
193  typedef \
194  ::blaze::CONSTRAINT_TEST< \
195  ::blaze::CONSTRAINT_MUST_NOT_HAVE_1_BYTE_FAILED< !::blaze::Has1Byte<T>::value >::value > \
196  BLAZE_JOIN( CONSTRAINT_MUST_NOT_HAVE_1_BYTE_TYPEDEF, __LINE__ )
197 //*************************************************************************************************
198 
199 
200 
201 
202 //=================================================================================================
203 //
204 // MUST_HAVE_2_BYTES CONSTRAINT
205 //
206 //=================================================================================================
207 
208 //*************************************************************************************************
218 template< bool > struct CONSTRAINT_MUST_HAVE_2_BYTES_FAILED;
219 template<> struct CONSTRAINT_MUST_HAVE_2_BYTES_FAILED<true> { enum { value = 1 }; };
221 //*************************************************************************************************
222 
223 
224 //*************************************************************************************************
230 #define BLAZE_CONSTRAINT_MUST_HAVE_2_BYTES(T) \
231  typedef \
232  ::blaze::CONSTRAINT_TEST< \
233  ::blaze::CONSTRAINT_MUST_HAVE_2_BYTES_FAILED< ::blaze::Has2Bytes<T>::value >::value > \
234  BLAZE_JOIN( CONSTRAINT_MUST_HAVE_2_BYTES_TYPEDEF, __LINE__ )
235 //*************************************************************************************************
236 
237 
238 
239 
240 //=================================================================================================
241 //
242 // MUST_NOT_HAVE_2_BYTES CONSTRAINT
243 //
244 //=================================================================================================
245 
246 //*************************************************************************************************
256 template< bool > struct CONSTRAINT_MUST_NOT_HAVE_2_BYTES_FAILED;
257 template<> struct CONSTRAINT_MUST_NOT_HAVE_2_BYTES_FAILED<true> { enum { value = 1 }; };
259 //*************************************************************************************************
260 
261 
262 //*************************************************************************************************
268 #define BLAZE_CONSTRAINT_MUST_NOT_HAVE_2_BYTES(T) \
269  typedef \
270  ::blaze::CONSTRAINT_TEST< \
271  ::blaze::CONSTRAINT_MUST_NOT_HAVE_2_BYTES_FAILED< !::blaze::Has2Bytes<T>::value >::value > \
272  BLAZE_JOIN( CONSTRAINT_MUST_NOT_HAVE_2_BYTES_TYPEDEF, __LINE__ )
273 //*************************************************************************************************
274 
275 
276 
277 
278 //=================================================================================================
279 //
280 // MUST_HAVE_4_BYTES CONSTRAINT
281 //
282 //=================================================================================================
283 
284 //*************************************************************************************************
294 template< bool > struct CONSTRAINT_MUST_HAVE_4_BYTES_FAILED;
295 template<> struct CONSTRAINT_MUST_HAVE_4_BYTES_FAILED<true> { enum { value = 1 }; };
297 //*************************************************************************************************
298 
299 
300 //*************************************************************************************************
306 #define BLAZE_CONSTRAINT_MUST_HAVE_4_BYTES(T) \
307  typedef \
308  ::blaze::CONSTRAINT_TEST< \
309  ::blaze::CONSTRAINT_MUST_HAVE_4_BYTES_FAILED< ::blaze::Has4Bytes<T>::value >::value > \
310  BLAZE_JOIN( CONSTRAINT_MUST_HAVE_4_BYTES_TYPEDEF, __LINE__ )
311 //*************************************************************************************************
312 
313 
314 
315 
316 //=================================================================================================
317 //
318 // MUST_NOT_HAVE_4_BYTES CONSTRAINT
319 //
320 //=================================================================================================
321 
322 //*************************************************************************************************
332 template< bool > struct CONSTRAINT_MUST_NOT_HAVE_4_BYTES_FAILED;
333 template<> struct CONSTRAINT_MUST_NOT_HAVE_4_BYTES_FAILED<true> { enum { value = 1 }; };
335 //*************************************************************************************************
336 
337 
338 //*************************************************************************************************
344 #define BLAZE_CONSTRAINT_MUST_NOT_HAVE_4_BYTES(T) \
345  typedef \
346  ::blaze::CONSTRAINT_TEST< \
347  ::blaze::CONSTRAINT_MUST_NOT_HAVE_4_BYTES_FAILED< !::blaze::Has4Bytes<T>::value >::value > \
348  BLAZE_JOIN( CONSTRAINT_MUST_NOT_HAVE_4_BYTES_TYPEDEF, __LINE__ )
349 //*************************************************************************************************
350 
351 
352 
353 
354 //=================================================================================================
355 //
356 // MUST_HAVE_8_BYTES CONSTRAINT
357 //
358 //=================================================================================================
359 
360 //*************************************************************************************************
370 template< bool > struct CONSTRAINT_MUST_HAVE_8_BYTES_FAILED;
371 template<> struct CONSTRAINT_MUST_HAVE_8_BYTES_FAILED<true> { enum { value = 1 }; };
373 //*************************************************************************************************
374 
375 
376 //*************************************************************************************************
382 #define BLAZE_CONSTRAINT_MUST_HAVE_8_BYTES(T) \
383  typedef \
384  ::blaze::CONSTRAINT_TEST< \
385  ::blaze::CONSTRAINT_MUST_HAVE_8_BYTES_FAILED< ::blaze::Has8Bytes<T>::value >::value > \
386  BLAZE_JOIN( CONSTRAINT_MUST_HAVE_8_BYTES_TYPEDEF, __LINE__ )
387 //*************************************************************************************************
388 
389 
390 
391 
392 //=================================================================================================
393 //
394 // MUST_NOT_HAVE_8_BYTES CONSTRAINT
395 //
396 //=================================================================================================
397 
398 //*************************************************************************************************
408 template< bool > struct CONSTRAINT_MUST_NOT_HAVE_8_BYTES_FAILED;
409 template<> struct CONSTRAINT_MUST_NOT_HAVE_8_BYTES_FAILED<true> { enum { value = 1 }; };
411 //*************************************************************************************************
412 
413 
414 //*************************************************************************************************
420 #define BLAZE_CONSTRAINT_MUST_NOT_HAVE_8_BYTES(T) \
421  typedef \
422  ::blaze::CONSTRAINT_TEST< \
423  ::blaze::CONSTRAINT_MUST_NOT_HAVE_8_BYTES_FAILED< !::blaze::Has8Bytes<T>::value >::value > \
424  BLAZE_JOIN( CONSTRAINT_MUST_NOT_HAVE_8_BYTES_TYPEDEF, __LINE__ )
425 //*************************************************************************************************
426 
427 } // namespace blaze
428 
429 #endif
Header file for the HasSize type trait.
Constraint wrapper class.
Header file for compile time constraints.