casacore
ValType.h
Go to the documentation of this file.
1 //# ValType.h: Data types and their undefined values
2 //# Copyright (C) 1993,1994,1995,1996,1998,2001,2002
3 //# Associated Universities, Inc. Washington DC, USA.
4 //#
5 //# This library is free software; you can redistribute it and/or modify it
6 //# under the terms of the GNU Library General Public License as published by
7 //# the Free Software Foundation; either version 2 of the License, or (at your
8 //# option) any later version.
9 //#
10 //# This library is distributed in the hope that it will be useful, but WITHOUT
11 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 //# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
13 //# License for more details.
14 //#
15 //# You should have received a copy of the GNU Library General Public License
16 //# along with this library; if not, write to the Free Software Foundation,
17 //# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
18 //#
19 //# Correspondence concerning AIPS++ should be addressed as follows:
20 //# Internet email: aips2-request@nrao.edu.
21 //# Postal address: AIPS++ Project Office
22 //# National Radio Astronomy Observatory
23 //# 520 Edgemont Road
24 //# Charlottesville, VA 22903-2475 USA
25 //#
26 //# $Id$
27 
28 #ifndef CASA_VALTYPE_H
29 #define CASA_VALTYPE_H
30 
31 
32 //# Includes
33 #include <casacore/casa/aips.h>
34 #include <casacore/casa/Utilities/DataType.h>
35 #include <casacore/casa/BasicSL/String.h>
36 #include <casacore/casa/BasicSL/Complex.h>
37 #include <casacore/casa/Utilities/Compare.h>
38 #include <casacore/casa/Utilities/CountedPtr.h>
39 #include <casacore/casa/OS/Conversion.h>
40 #include <casacore/casa/IO/AipsIO.h>
41 #include <casacore/casa/iosfwd.h>
42 
43 namespace casacore { //# NAMESPACE CASACORE - BEGIN
44 
45 //# Forward Declarations
46 class TableRecord;
47 
48 
49 // <summary>
50 // Data types and their undefined values.
51 // </summary>
52 
53 // <use visibility=export>
54 
55 // <reviewed reviewer="Friso olnon" date="1995/03/20" tests="" demos="">
56 // </reviewed>
57 
58 // <prerequisite>
59 // <li> enum <linkto group="DataType.h#DataType">DataType</linkto>
60 // </prerequisite>
61 
62 // <synopsis>
63 // Class <src>ValType</src> describes the data types and their
64 // "undefined values".
65 //
66 // Supported are built-in data types, <src>Bool</src>,
67 // <src>String</src>, <src>Complex</src> and <src>DComplex</src>.
68 // As a rule, the smallest possible value of a data type is used as its
69 // "undefined value"; for <src>String</src> we use the null string, and
70 // for <src>Bool</src> the value <em>False</em>.
71 //
72 // The class does not contain data. It merely defines constants and
73 // has overloaded functions that return in some form the "undefined
74 // value", the data type, or certain other information about the data
75 // type.
76 // </synopsis>
77 
78 
79 class ValType {
80 public:
81 
82  // Get the "undefined value" for this data type as the function's
83  // return value.
84  //<group>
85  static Bool undefBool ();
86  static Char undefChar ();
87  static uChar undefUChar ();
88  static Short undefShort ();
89  static uShort undefUShort ();
90  static Int undefInt ();
91  static uInt undefUInt ();
92  static Int64 undefInt64 ();
93  static float undefFloat ();
94  static double undefDouble ();
95  static Complex undefComplex ();
96  static DComplex undefDComplex ();
97  static String undefString ();
98  //</group>
99 
100  // Get the "undefined value" for this data type in the argument.
101  // The <src>void*</src> function is not doing anything and is for
102  // TpOther types.
103  //<group>
104  static void getUndef (Bool*);
105  static void getUndef (Char*);
106  static void getUndef (uChar*);
107  static void getUndef (Short*);
108  static void getUndef (uShort*);
109  static void getUndef (Int*);
110  static void getUndef (uInt*);
111  static void getUndef (Int64*);
112  static void getUndef (float*);
113  static void getUndef (double*);
114  static void getUndef (Complex*);
115  static void getUndef (DComplex*);
116  static void getUndef (String*);
117  static void getUndef (void*);
118  //</group>
119 
120  // Get the data type code for this type as the function's
121  // return value.
122  //<group>
123  static DataType getType (const Bool*);
124  static DataType getType (const Char*);
125  static DataType getType (const uChar*);
126  static DataType getType (const Short*);
127  static DataType getType (const uShort*);
128  static DataType getType (const Int*);
129  static DataType getType (const uInt*);
130  static DataType getType (const Int64*);
131  static DataType getType (const float*);
132  static DataType getType (const double*);
133  static DataType getType (const Complex*);
134  static DataType getType (const DComplex*);
135  static DataType getType (const String*);
136  static DataType getType (const TableRecord*);
137  static DataType getType (const void*);
138  //</group>
139 
140  // Get the name of the data type. The <src>void*</src> returns
141  // the string "Other ".
142  //<group>
143  static const String& getTypeStr (DataType);
144  static const String& getTypeStr (const Bool*);
145  static const String& getTypeStr (const Char*);
146  static const String& getTypeStr (const uChar*);
147  static const String& getTypeStr (const Short*);
148  static const String& getTypeStr (const uShort*);
149  static const String& getTypeStr (const Int*);
150  static const String& getTypeStr (const uInt*);
151  static const String& getTypeStr (const Int64*);
152  static const String& getTypeStr (const float*);
153  static const String& getTypeStr (const double*);
154  static const String& getTypeStr (const Complex*);
155  static const String& getTypeStr (const DComplex*);
156  static const String& getTypeStr (const String*);
157  static const String& getTypeStr (const TableRecord*);
158  static const String& getTypeStr (const void*);
159  //</group>
160 
161  // Get the size of data type (in local format).
162  static int getTypeSize (DataType);
163 
164  // Get the size of data type in canonical format.
165  // <br>The argument <src>BECanonical</src> determines if the big-endian
166  // or little-endian canonical format is used.
167  static int getCanonicalSize (DataType, Bool BECanonical = True);
168 
169  // Get the functions to convert to/from canonical format.
170  // These functions take the number of pixels as the length argument.
171  // It returns the number of elements per value; normally this is 1,
172  // but for complex values it is 2 (since they convert float/double).
173  // <br>The argument <src>BECanonical</src> determines if the big-endian
174  // or little-endian canonical format is used.
175  static void getCanonicalFunc (DataType dt,
176  Conversion::ValueFunction*& readFunc,
177  Conversion::ValueFunction*& writeFunc,
178  uInt& nrElementsPerValue,
179  Bool BECanonical = True);
180 
181  // Test if a data type can be promoted to another.
182  static Bool isPromotable (DataType from, DataType to);
183 
184  // Get the pointer to the routine which compares two values.
185  static ObjCompareFunc* getCmpFunc (DataType);
186 
187  // Get the object which compares two values.
188  static CountedPtr<BaseCompare> getCmpObj (DataType);
189 
190  // Put the value into <src>AipsIO</src>.
191  // The <src>void*</src> function is not doing anything and is for
192  // TpOther types.
193  //<group>
194  static void put (AipsIO&, const Bool*);
195  static void put (AipsIO&, const Char*);
196  static void put (AipsIO&, const uChar*);
197  static void put (AipsIO&, const Short*);
198  static void put (AipsIO&, const uShort*);
199  static void put (AipsIO&, const Int*);
200  static void put (AipsIO&, const uInt*);
201  static void put (AipsIO&, const Int64*);
202  static void put (AipsIO&, const float*);
203  static void put (AipsIO&, const double*);
204  static void put (AipsIO&, const Complex*);
205  static void put (AipsIO&, const DComplex*);
206  static void put (AipsIO&, const String*);
207  static void put (AipsIO&, const void*);
208  //</group>
209 
210  // Get the value from <src>AipsIO</src>.
211  // The <src>void*</src> function is not doing anything and is for
212  // TpOther types.
213  //<group>
214  static void get (AipsIO&, Bool*);
215  static void get (AipsIO&, Char*);
216  static void get (AipsIO&, uChar*);
217  static void get (AipsIO&, Short*);
218  static void get (AipsIO&, uShort*);
219  static void get (AipsIO&, Int*);
220  static void get (AipsIO&, uInt*);
221  static void get (AipsIO&, Int64*);
222  static void get (AipsIO&, float*);
223  static void get (AipsIO&, double*);
224  static void get (AipsIO&, Complex*);
225  static void get (AipsIO&, DComplex*);
226  static void get (AipsIO&, String*);
227  static void get (AipsIO&, void*);
228  //</group>
229 
230  // Put the value into the <src>ostream</src>.
231  // The <src>void*</src> function is not doing anything and is for
232  // TpOther types.
233  //<group>
234  static void put (ostream&, const Bool*);
235  static void put (ostream&, const Char*);
236  static void put (ostream&, const uChar*);
237  static void put (ostream&, const Short*);
238  static void put (ostream&, const uShort*);
239  static void put (ostream&, const Int*);
240  static void put (ostream&, const uInt*);
241  static void put (ostream&, const Int64*);
242  static void put (ostream&, const float*);
243  static void put (ostream&, const double*);
244  static void put (ostream&, const Complex*);
245  static void put (ostream&, const DComplex*);
246  static void put (ostream&, const String*);
247  static void put (ostream&, const void*);
248  //</group>
249 
250  // Check if a value is defined, i.e. if it mismatches the given
251  // undefined value. The <src>void*</src> function (for non-standard
252  // data types) always returns the value <src>1</src>, since such
253  // values cannot be undefined.
254  //<group>
255  static int isDefined (const Bool* value, const Bool* undef);
256  static int isDefined (const Char* value, const Char* undef);
257  static int isDefined (const uChar* value, const uChar* undef);
258  static int isDefined (const Short* value, const Short* undef);
259  static int isDefined (const uShort* value, const uShort* undef);
260  static int isDefined (const Int* value, const Int* undef);
261  static int isDefined (const uInt* value, const uInt* undef);
262  static int isDefined (const Int64* value, const Int64* undef);
263  static int isDefined (const float* value, const float* undef);
264  static int isDefined (const double* value, const double* undef);
265  static int isDefined (const Complex* value, const Complex* undef);
266  static int isDefined (const DComplex* value, const DComplex* undef);
267  static int isDefined (const String* value, const String* undef);
268  static int isDefined (const void* value, const void* undef);
269  //</group>
270 
271 private:
272  static const Bool undefbool ;
273  static const Char undefchar ;
274  static const uChar undefuchar ;
275  static const Short undefshort ;
276  static const uShort undefushort ;
277  static const Int undefint ;
278  static const uInt undefuint ;
279  static const Int64 undefint64 ;
280  static const float undeffloat ;
281  static const double undefdouble ;
282  static const Complex undefcomplex ;
283  static const DComplex undefdcomplex;
284  static const String undefstring ;
285 
286  static const String strbool;
287  static const String strchar;
288  static const String struchar;
289  static const String strshort;
290  static const String strushort;
291  static const String strint;
292  static const String struint;
293  static const String strint64;
294  static const String strfloat;
295  static const String strdouble;
296  static const String strcomplex;
297  static const String strdcomplex;
298  static const String strstring;
299  static const String strrecord;
300  static const String strtable;
301  static const String strother;
302  static const String strunknown;
303  //
304  // This class is not meant to be constructed.
305  //
306  ValType ();
307 };
308 
309 
310 
312  {return undefbool;}
314  {return undefchar;}
316  {return undefuchar;}
318  {return undefshort;}
320  {return undefushort;}
322  {return undefint;}
324  {return undefuint;}
326  {return undefint64;}
327 inline float ValType::undefFloat ()
328  {return undeffloat;}
329 inline double ValType::undefDouble ()
330  {return undefdouble;}
332  {return undefcomplex;}
334  {return undefdcomplex;}
336  {return undefstring;}
337 
338 
339 inline void ValType::getUndef (Bool* val)
340  {*val = undefbool;}
341 inline void ValType::getUndef (Char* val)
342  {*val = undefchar;}
343 inline void ValType::getUndef (uChar* val)
344  {*val = undefuchar;}
345 inline void ValType::getUndef (Short* val)
346  {*val = undefshort;}
347 inline void ValType::getUndef (uShort* val)
348  {*val = undefushort;}
349 inline void ValType::getUndef (Int* val)
350  {*val = undefint;}
351 inline void ValType::getUndef (uInt* val)
352  {*val = undefuint;}
353 inline void ValType::getUndef (Int64* val)
354  {*val = undefint64;}
355 inline void ValType::getUndef (float* val)
356  {*val = undeffloat;}
357 inline void ValType::getUndef (double* val)
358  {*val = undefdouble;}
359 inline void ValType::getUndef (Complex* val)
360  {*val = undefcomplex;}
361 inline void ValType::getUndef (DComplex* val)
362  {*val = undefdcomplex;}
363 inline void ValType::getUndef (String* val)
364  {*val = undefstring;}
365 inline void ValType::getUndef (void*)
366  {}
367 
368 inline DataType ValType::getType (const Bool*)
369  {return TpBool;}
370 inline DataType ValType::getType (const Char*)
371  {return TpChar;}
372 inline DataType ValType::getType (const uChar*)
373  {return TpUChar;}
374 inline DataType ValType::getType (const Short*)
375  {return TpShort;}
376 inline DataType ValType::getType (const uShort*)
377  {return TpUShort;}
378 inline DataType ValType::getType (const Int*)
379  {return TpInt;}
380 inline DataType ValType::getType (const uInt*)
381  {return TpUInt;}
382 inline DataType ValType::getType (const Int64*)
383  {return TpInt64;}
384 inline DataType ValType::getType (const float*)
385  {return TpFloat;}
386 inline DataType ValType::getType (const double*)
387  {return TpDouble;}
388 inline DataType ValType::getType (const Complex*)
389  {return TpComplex;}
390 inline DataType ValType::getType (const DComplex*)
391  {return TpDComplex;}
392 inline DataType ValType::getType (const String*)
393  {return TpString;}
394 inline DataType ValType::getType (const TableRecord*)
395  {return TpRecord;}
396 inline DataType ValType::getType (const void*)
397  {return TpOther;}
398 
399 inline const String& ValType::getTypeStr (const Bool*)
400  {return strbool;}
401 inline const String& ValType::getTypeStr (const Char*)
402  {return strchar;}
403 inline const String& ValType::getTypeStr (const uChar*)
404  {return struchar;}
405 inline const String& ValType::getTypeStr (const Short*)
406  {return strshort;}
407 inline const String& ValType::getTypeStr (const uShort*)
408  {return strushort;}
409 inline const String& ValType::getTypeStr (const Int*)
410  {return strint;}
411 inline const String& ValType::getTypeStr (const uInt*)
412  {return struint;}
413 inline const String& ValType::getTypeStr (const Int64*)
414  {return strint64;}
415 inline const String& ValType::getTypeStr (const float*)
416  {return strfloat;}
417 inline const String& ValType::getTypeStr (const double*)
418  {return strdouble;}
419 inline const String& ValType::getTypeStr (const Complex*)
420  {return strcomplex;}
421 inline const String& ValType::getTypeStr (const DComplex*)
422  {return strdcomplex;}
423 inline const String& ValType::getTypeStr (const String*)
424  {return strstring;}
425 inline const String& ValType::getTypeStr (const TableRecord*)
426  {return strrecord;}
427 inline const String& ValType::getTypeStr (const void*)
428  {return strother;}
429 
430 inline void ValType::put (AipsIO& ios, const Bool* value)
431  {ios << *value;}
432 inline void ValType::put (AipsIO& ios, const Char* value)
433  {ios << *value;}
434 inline void ValType::put (AipsIO& ios, const uChar* value)
435  {ios << *value;}
436 inline void ValType::put (AipsIO& ios, const Short* value)
437  {ios << *value;}
438 inline void ValType::put (AipsIO& ios, const uShort* value)
439  {ios << *value;}
440 inline void ValType::put (AipsIO& ios, const Int* value)
441  {ios << *value;}
442 inline void ValType::put (AipsIO& ios, const uInt* value)
443  {ios << *value;}
444 inline void ValType::put (AipsIO& ios, const Int64* value)
445  {ios << *value;}
446 inline void ValType::put (AipsIO& ios, const float* value)
447  {ios << *value;}
448 inline void ValType::put (AipsIO& ios, const double* value)
449  {ios << *value;}
450 inline void ValType::put (AipsIO& ios, const Complex* value)
451  {ios << *value;}
452 inline void ValType::put (AipsIO& ios, const DComplex* value)
453  {ios << *value;}
454 inline void ValType::put (AipsIO& ios, const String* value)
455  {ios << *value;}
456 inline void ValType::put (AipsIO&, const void*)
457  {}
458 
459 inline void ValType::get (AipsIO& ios, Bool* value)
460  {ios >> *value;}
461 inline void ValType::get (AipsIO& ios, Char* value)
462  {ios >> *value;}
463 inline void ValType::get (AipsIO& ios, uChar* value)
464  {ios >> *value;}
465 inline void ValType::get (AipsIO& ios, Short* value)
466  {ios >> *value;}
467 inline void ValType::get (AipsIO& ios, uShort* value)
468  {ios >> *value;}
469 inline void ValType::get (AipsIO& ios, Int* value)
470  {ios >> *value;}
471 inline void ValType::get (AipsIO& ios, uInt* value)
472  {ios >> *value;}
473 inline void ValType::get (AipsIO& ios, Int64* value)
474  {ios >> *value;}
475 inline void ValType::get (AipsIO& ios, float* value)
476  {ios >> *value;}
477 inline void ValType::get (AipsIO& ios, double* value)
478  {ios >> *value;}
479 inline void ValType::get (AipsIO& ios, Complex* value)
480  {ios >> *value;}
481 inline void ValType::get (AipsIO& ios, DComplex* value)
482  {ios >> *value;}
483 inline void ValType::get (AipsIO& ios, String* value)
484  {ios >> *value;}
485 inline void ValType::get (AipsIO&, void*)
486  {}
487 
488 inline void ValType::put (ostream& ios, const Bool* value)
489  {ios << *value;}
490 inline void ValType::put (ostream& ios, const Char* value)
491  {ios << *value;}
492 inline void ValType::put (ostream& ios, const uChar* value)
493  {ios << *value;}
494 inline void ValType::put (ostream& ios, const Short* value)
495  {ios << *value;}
496 inline void ValType::put (ostream& ios, const uShort* value)
497  {ios << *value;}
498 inline void ValType::put (ostream& ios, const Int* value)
499  {ios << *value;}
500 inline void ValType::put (ostream& ios, const uInt* value)
501  {ios << *value;}
502 inline void ValType::put (ostream& ios, const Int64* value)
503  {ios << *value;}
504 inline void ValType::put (ostream& ios, const float* value)
505  {ios << *value;}
506 inline void ValType::put (ostream& ios, const double* value)
507  {ios << *value;}
508 inline void ValType::put (ostream& ios, const Complex* value)
509  {ios << *value;}
510 inline void ValType::put (ostream& ios, const DComplex* value)
511  {ios << *value;}
512 inline void ValType::put (ostream& ios, const String* value)
513  {ios << *value;}
514 inline void ValType::put (ostream&, const void*)
515  {}
516 
517 
518 inline int ValType::isDefined (const Bool* value, const Bool* undef)
519  {return *value != *undef;}
520 inline int ValType::isDefined (const Char* value, const Char* undef)
521  {return *value != *undef;}
522 inline int ValType::isDefined (const uChar* value, const uChar* undef)
523  {return *value != *undef;}
524 inline int ValType::isDefined (const Short* value, const Short* undef)
525  {return *value != *undef;}
526 inline int ValType::isDefined (const uShort* value, const uShort* undef)
527  {return *value != *undef;}
528 inline int ValType::isDefined (const Int* value, const Int* undef)
529  {return *value != *undef;}
530 inline int ValType::isDefined (const uInt* value, const uInt* undef)
531  {return *value != *undef;}
532 inline int ValType::isDefined (const Int64* value, const Int64* undef)
533  {return *value != *undef;}
534 inline int ValType::isDefined (const float* value, const float* undef)
535  {return *value != *undef;}
536 inline int ValType::isDefined (const double* value, const double* undef)
537  {return *value != *undef;}
538 inline int ValType::isDefined (const Complex* value, const Complex* undef)
539  {return *value != *undef;}
540 inline int ValType::isDefined (const DComplex* value, const DComplex* undef)
541  {return *value != *undef;}
542 inline int ValType::isDefined (const String* value, const String* undef)
543  {return *value != *undef;}
544 inline int ValType::isDefined (const void*, const void*)
545  {return 1;}
546 
547 
548 
549 } //# NAMESPACE CASACORE - END
550 
551 #endif
552 
553 
554 
static const String & getTypeStr(DataType)
Get the name of the data type.
static const Int64 undefint64
Definition: ValType.h:279
long long Int64
Define the extra non-standard types used by Casacore (like proposed uSize, Size)
Definition: aipsxtype.h:38
int Int
Definition: aipstype.h:47
static DComplex undefDComplex()
Definition: ValType.h:333
static uInt undefUInt()
Definition: ValType.h:323
static const Int undefint
Definition: ValType.h:277
static int getTypeSize(DataType)
Get the size of data type (in local format).
static const String strbool
Definition: ValType.h:286
static double undefDouble()
Definition: ValType.h:329
AipsIO is the object persistency mechanism of Casacore.
Definition: AipsIO.h:168
static const String strchar
Definition: ValType.h:287
static const double undefdouble
Definition: ValType.h:281
static int isDefined(const Bool *value, const Bool *undef)
Check if a value is defined, i.e.
Definition: ValType.h:518
unsigned char uChar
Definition: aipstype.h:44
static const Complex undefcomplex
Definition: ValType.h:282
static const String struint
Definition: ValType.h:292
static const Short undefshort
Definition: ValType.h:275
char Char
Definition: aipstype.h:43
ValType()
This class is not meant to be constructed.
static const String strother
Definition: ValType.h:301
static const String strunknown
Definition: ValType.h:302
static const DComplex undefdcomplex
Definition: ValType.h:283
static const String strshort
Definition: ValType.h:289
static const String strint
Definition: ValType.h:291
short Short
Definition: aipstype.h:45
Data types and their undefined values.
Definition: ValType.h:79
static uShort undefUShort()
Definition: ValType.h:319
static Bool isPromotable(DataType from, DataType to)
Test if a data type can be promoted to another.
static const String strfloat
Definition: ValType.h:294
static const float undeffloat
Definition: ValType.h:280
static Short undefShort()
Definition: ValType.h:317
static const String struchar
Definition: ValType.h:288
static const uInt undefuint
Definition: ValType.h:278
static const String undefstring
Definition: ValType.h:284
Referenced counted pointer for constant data.
Definition: CountedPtr.h:86
static void get(AipsIO &, Bool *)
Get the value from AipsIO.
Definition: ValType.h:459
static ObjCompareFunc * getCmpFunc(DataType)
Get the pointer to the routine which compares two values.
static Int64 undefInt64()
Definition: ValType.h:325
static const String strushort
Definition: ValType.h:290
static DataType getType(const Bool *)
Get the data type code for this type as the function&#39;s return value.
Definition: ValType.h:368
static const String strdcomplex
Definition: ValType.h:297
static const String strstring
Definition: ValType.h:298
bool Bool
Define the standard types used by Casacore.
Definition: aipstype.h:39
static Char undefChar()
Definition: ValType.h:313
static const Char undefchar
Definition: ValType.h:273
static const String strcomplex
Definition: ValType.h:296
static Int undefInt()
Definition: ValType.h:321
static const String strtable
Definition: ValType.h:300
static const uChar undefuchar
Definition: ValType.h:274
static void put(AipsIO &, const Bool *)
Put the value into AipsIO.
Definition: ValType.h:430
static float undefFloat()
Definition: ValType.h:327
static void getUndef(Bool *)
Get the "undefined value" for this data type in the argument.
Definition: ValType.h:339
A hierarchical collection of named fields of various types.
Definition: TableRecord.h:182
static const String strdouble
Definition: ValType.h:295
static const String strrecord
Definition: ValType.h:299
static String undefString()
Definition: ValType.h:335
static const String strint64
Definition: ValType.h:293
static void getCanonicalFunc(DataType dt, Conversion::ValueFunction *&readFunc, Conversion::ValueFunction *&writeFunc, uInt &nrElementsPerValue, Bool BECanonical=True)
Get the functions to convert to/from canonical format.
String: the storage and methods of handling collections of characters.
Definition: String.h:223
static CountedPtr< BaseCompare > getCmpObj(DataType)
Get the object which compares two values.
static Complex undefComplex()
Definition: ValType.h:331
static int getCanonicalSize(DataType, Bool BECanonical=True)
Get the size of data type in canonical format.
const Bool True
Definition: aipstype.h:40
this file contains all the compiler specific defines
Definition: mainpage.dox:28
static uChar undefUChar()
Definition: ValType.h:315
LatticeExprNode value(const LatticeExprNode &expr)
This function returns the value of the expression without a mask.
unsigned int uInt
Definition: aipstype.h:48
size_t ValueFunction(void *to, const void *from, size_t nvalues)
Define the signature of a function converting nvalues values from internal to external format or vice...
Definition: Conversion.h:100
static const uShort undefushort
Definition: ValType.h:276
unsigned short uShort
Definition: aipstype.h:46
static Bool undefBool()
Get the "undefined value" for this data type as the function&#39;s return value.
Definition: ValType.h:311
static const Bool undefbool
Definition: ValType.h:272