casacore
Loading...
Searching...
No Matches
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
43namespace casacore { //# NAMESPACE CASACORE - BEGIN
44
45//# Forward Declarations
46class 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
79class ValType {
80public:
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.
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
271private:
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 String result("Bool ");
288 return result;
289 }
290 static const String &strchar( ) {
291 static String result("Char ");
292 return result;
293 }
294 static const String &struchar( ) {
295 static String result("uChar ");
296 return result;
297 }
298 static const String &strshort( ) {
299 static String result("Short ");
300 return result;
301 }
302 static const String &strushort( ) {
303 static String result("uShort ");
304 return result;
305 }
306 static const String &strint( ) {
307 static String result("Int ");
308 return result;
309 }
310 static const String &struint( ) {
311 static String result("uInt ");
312 return result;
313 }
314 static const String &strint64( ) {
315 static String result("Int64 ");
316 return result;
317 }
318 static const String &strfloat( ) {
319 static String result("float ");
320 return result;
321 }
322 static const String &strdouble( ) {
323 static String result("double ");
324 return result;
325 }
326 static const String &strcomplex( ) {
327 static String result("Complex ");
328 return result;
329 }
330 static const String &strdcomplex( ) {
331 static String result("DComplex");
332 return result;
333 }
334 static const String &strstring( ) {
335 static String result("String ");
336 return result;
337 }
338 static const String &strrecord( ) {
339 static String result("Record ");
340 return result;
341 }
342 static const String &strtable( ) {
343 static String result("Table ");
344 return result;
345 }
346 static const String &strother( ) {
347 static String result("Other ");
348 return result;
349 }
350 static const String &strunknown( ) {
351 static String result("unknown ");
352 return result;
353 }
354 //
355 // This class is not meant to be constructed.
356 //
358};
359
360
361
363 {return undefbool;}
365 {return undefchar;}
367 {return undefuchar;}
369 {return undefshort;}
373 {return undefint;}
375 {return undefuint;}
377 {return undefint64;}
378inline float ValType::undefFloat ()
379 {return undeffloat;}
380inline double ValType::undefDouble ()
381 {return undefdouble;}
382inline Complex ValType::undefComplex ()
383 {return undefcomplex;}
384inline DComplex ValType::undefDComplex ()
385 {return undefdcomplex;}
388
389
390inline void ValType::getUndef (Bool* val)
391 {*val = undefbool;}
392inline void ValType::getUndef (Char* val)
393 {*val = undefchar;}
394inline void ValType::getUndef (uChar* val)
395 {*val = undefuchar;}
396inline void ValType::getUndef (Short* val)
397 {*val = undefshort;}
398inline void ValType::getUndef (uShort* val)
399 {*val = undefushort;}
400inline void ValType::getUndef (Int* val)
401 {*val = undefint;}
402inline void ValType::getUndef (uInt* val)
403 {*val = undefuint;}
404inline void ValType::getUndef (Int64* val)
405 {*val = undefint64;}
406inline void ValType::getUndef (float* val)
407 {*val = undeffloat;}
408inline void ValType::getUndef (double* val)
409 {*val = undefdouble;}
410inline void ValType::getUndef (Complex* val)
411 {*val = undefcomplex;}
412inline void ValType::getUndef (DComplex* val)
413 {*val = undefdcomplex;}
414inline void ValType::getUndef (String* val)
415 {*val = undefstring;}
416inline void ValType::getUndef (void*)
417 {}
418
419inline DataType ValType::getType (const Bool*)
420 {return TpBool;}
421inline DataType ValType::getType (const Char*)
422 {return TpChar;}
423inline DataType ValType::getType (const uChar*)
424 {return TpUChar;}
425inline DataType ValType::getType (const Short*)
426 {return TpShort;}
427inline DataType ValType::getType (const uShort*)
428 {return TpUShort;}
429inline DataType ValType::getType (const Int*)
430 {return TpInt;}
431inline DataType ValType::getType (const uInt*)
432 {return TpUInt;}
433inline DataType ValType::getType (const Int64*)
434 {return TpInt64;}
435inline DataType ValType::getType (const float*)
436 {return TpFloat;}
437inline DataType ValType::getType (const double*)
438 {return TpDouble;}
439inline DataType ValType::getType (const Complex*)
440 {return TpComplex;}
441inline DataType ValType::getType (const DComplex*)
442 {return TpDComplex;}
443inline DataType ValType::getType (const String*)
444 {return TpString;}
445inline DataType ValType::getType (const TableRecord*)
446 {return TpRecord;}
447inline DataType ValType::getType (const void*)
448 {return TpOther;}
449
450inline const String& ValType::getTypeStr (const Bool*)
451 {return strbool();}
452inline const String& ValType::getTypeStr (const Char*)
453 {return strchar();}
454inline const String& ValType::getTypeStr (const uChar*)
455 {return struchar();}
456inline const String& ValType::getTypeStr (const Short*)
457 {return strshort();}
458inline const String& ValType::getTypeStr (const uShort*)
459 {return strushort();}
460inline const String& ValType::getTypeStr (const Int*)
461 {return strint();}
462inline const String& ValType::getTypeStr (const uInt*)
463 {return struint();}
464inline const String& ValType::getTypeStr (const Int64*)
465 {return strint64();}
466inline const String& ValType::getTypeStr (const float*)
467 {return strfloat();}
468inline const String& ValType::getTypeStr (const double*)
469 {return strdouble();}
470inline const String& ValType::getTypeStr (const Complex*)
471 {return strcomplex();}
472inline const String& ValType::getTypeStr (const DComplex*)
473 {return strdcomplex();}
474inline const String& ValType::getTypeStr (const String*)
475 {return strstring();}
477 {return strrecord();}
478inline const String& ValType::getTypeStr (const void*)
479 {return strother();}
480
481inline void ValType::put (AipsIO& ios, const Bool* value)
482 {ios << *value;}
483inline void ValType::put (AipsIO& ios, const Char* value)
484 {ios << *value;}
485inline void ValType::put (AipsIO& ios, const uChar* value)
486 {ios << *value;}
487inline void ValType::put (AipsIO& ios, const Short* value)
488 {ios << *value;}
489inline void ValType::put (AipsIO& ios, const uShort* value)
490 {ios << *value;}
491inline void ValType::put (AipsIO& ios, const Int* value)
492 {ios << *value;}
493inline void ValType::put (AipsIO& ios, const uInt* value)
494 {ios << *value;}
495inline void ValType::put (AipsIO& ios, const Int64* value)
496 {ios << *value;}
497inline void ValType::put (AipsIO& ios, const float* value)
498 {ios << *value;}
499inline void ValType::put (AipsIO& ios, const double* value)
500 {ios << *value;}
501inline void ValType::put (AipsIO& ios, const Complex* value)
502 {ios << *value;}
503inline void ValType::put (AipsIO& ios, const DComplex* value)
504 {ios << *value;}
505inline void ValType::put (AipsIO& ios, const String* value)
506 {ios << *value;}
507inline void ValType::put (AipsIO&, const void*)
508 {}
509
510inline void ValType::get (AipsIO& ios, Bool* value)
511 {ios >> *value;}
512inline void ValType::get (AipsIO& ios, Char* value)
513 {ios >> *value;}
514inline void ValType::get (AipsIO& ios, uChar* value)
515 {ios >> *value;}
516inline void ValType::get (AipsIO& ios, Short* value)
517 {ios >> *value;}
518inline void ValType::get (AipsIO& ios, uShort* value)
519 {ios >> *value;}
520inline void ValType::get (AipsIO& ios, Int* value)
521 {ios >> *value;}
522inline void ValType::get (AipsIO& ios, uInt* value)
523 {ios >> *value;}
524inline void ValType::get (AipsIO& ios, Int64* value)
525 {ios >> *value;}
526inline void ValType::get (AipsIO& ios, float* value)
527 {ios >> *value;}
528inline void ValType::get (AipsIO& ios, double* value)
529 {ios >> *value;}
530inline void ValType::get (AipsIO& ios, Complex* value)
531 {ios >> *value;}
532inline void ValType::get (AipsIO& ios, DComplex* value)
533 {ios >> *value;}
534inline void ValType::get (AipsIO& ios, String* value)
535 {ios >> *value;}
536inline void ValType::get (AipsIO&, void*)
537 {}
538
539inline void ValType::put (ostream& ios, const Bool* value)
540 {ios << *value;}
541inline void ValType::put (ostream& ios, const Char* value)
542 {ios << *value;}
543inline void ValType::put (ostream& ios, const uChar* value)
544 {ios << *value;}
545inline void ValType::put (ostream& ios, const Short* value)
546 {ios << *value;}
547inline void ValType::put (ostream& ios, const uShort* value)
548 {ios << *value;}
549inline void ValType::put (ostream& ios, const Int* value)
550 {ios << *value;}
551inline void ValType::put (ostream& ios, const uInt* value)
552 {ios << *value;}
553inline void ValType::put (ostream& ios, const Int64* value)
554 {ios << *value;}
555inline void ValType::put (ostream& ios, const float* value)
556 {ios << *value;}
557inline void ValType::put (ostream& ios, const double* value)
558 {ios << *value;}
559inline void ValType::put (ostream& ios, const Complex* value)
560 {ios << *value;}
561inline void ValType::put (ostream& ios, const DComplex* value)
562 {ios << *value;}
563inline void ValType::put (ostream& ios, const String* value)
564 {ios << *value;}
565inline void ValType::put (ostream&, const void*)
566 {}
567
568
569inline int ValType::isDefined (const Bool* value, const Bool* undef)
570 {return *value != *undef;}
571inline int ValType::isDefined (const Char* value, const Char* undef)
572 {return *value != *undef;}
573inline int ValType::isDefined (const uChar* value, const uChar* undef)
574 {return *value != *undef;}
575inline int ValType::isDefined (const Short* value, const Short* undef)
576 {return *value != *undef;}
577inline int ValType::isDefined (const uShort* value, const uShort* undef)
578 {return *value != *undef;}
579inline int ValType::isDefined (const Int* value, const Int* undef)
580 {return *value != *undef;}
581inline int ValType::isDefined (const uInt* value, const uInt* undef)
582 {return *value != *undef;}
583inline int ValType::isDefined (const Int64* value, const Int64* undef)
584 {return *value != *undef;}
585inline int ValType::isDefined (const float* value, const float* undef)
586 {return *value != *undef;}
587inline int ValType::isDefined (const double* value, const double* undef)
588 {return *value != *undef;}
589inline int ValType::isDefined (const Complex* value, const Complex* undef)
590 {return *value != *undef;}
591inline int ValType::isDefined (const DComplex* value, const DComplex* undef)
592 {return *value != *undef;}
593inline int ValType::isDefined (const String* value, const String* undef)
594 {return *value != *undef;}
595inline int ValType::isDefined (const void*, const void*)
596 {return 1;}
597
598
599
600} //# NAMESPACE CASACORE - END
601
602#endif
603
604
605
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
Referenced counted pointer for constant data.
Definition CountedPtr.h:81
String: the storage and methods of handling collections of characters.
Definition String.h:225
static const String & strshort()
Definition ValType.h:298
static void getUndef(Bool *)
Get the "undefined value" for this data type in the argument.
Definition ValType.h:390
static ObjCompareFunc * getCmpFunc(DataType)
Get the pointer to the routine which compares two values.
ValType()
This class is not meant to be constructed.
static const String & strdcomplex()
Definition ValType.h:330
static const String & strint()
Definition ValType.h:306
static const String & strrecord()
Definition ValType.h:338
static float undefFloat()
Definition ValType.h:378
static Char undefChar()
Definition ValType.h:364
static int getCanonicalSize(DataType, Bool BECanonical=True)
Get the size of data type in canonical format.
static Short undefShort()
Definition ValType.h:368
static Bool undefBool()
Get the "undefined value" for this data type as the function's return value.
Definition ValType.h:362
static const String undefstring
Definition ValType.h:284
static Int undefInt()
Definition ValType.h:372
static const String & strother()
Definition ValType.h:346
static const Char undefchar
Definition ValType.h:273
static String undefString()
Definition ValType.h:386
static const String & strfloat()
Definition ValType.h:318
static const float undeffloat
Definition ValType.h:280
static int getTypeSize(DataType)
Get the size of data type (in local format).
static const Complex undefcomplex
Definition ValType.h:282
static const double undefdouble
Definition ValType.h:281
static const String & strushort()
Definition ValType.h:302
static const String & strchar()
Definition ValType.h:290
static const Short undefshort
Definition ValType.h:275
static Bool isPromotable(DataType from, DataType to)
Test if a data type can be promoted to another.
static const uInt undefuint
Definition ValType.h:278
static const String & strbool()
Definition ValType.h:286
static const String & strint64()
Definition ValType.h:314
static Complex undefComplex()
Definition ValType.h:382
static const uChar undefuchar
Definition ValType.h:274
static DComplex undefDComplex()
Definition ValType.h:384
static const Int64 undefint64
Definition ValType.h:279
static CountedPtr< BaseCompare > getCmpObj(DataType)
Get the object which compares two values.
static const String & strunknown()
Definition ValType.h:350
static void put(AipsIO &, const Bool *)
Put the value into AipsIO.
Definition ValType.h:481
static const String & strdouble()
Definition ValType.h:322
static const Int undefint
Definition ValType.h:277
static DataType getType(const Bool *)
Get the data type code for this type as the function's return value.
Definition ValType.h:419
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.
static Int64 undefInt64()
Definition ValType.h:376
static const String & struchar()
Definition ValType.h:294
static uChar undefUChar()
Definition ValType.h:366
static const String & getTypeStr(DataType)
Get the name of the data type.
static double undefDouble()
Definition ValType.h:380
static const uShort undefushort
Definition ValType.h:276
static uShort undefUShort()
Definition ValType.h:370
static void get(AipsIO &, Bool *)
Get the value from AipsIO.
Definition ValType.h:510
static uInt undefUInt()
Definition ValType.h:374
static const String & strcomplex()
Definition ValType.h:326
static const Bool undefbool
Definition ValType.h:272
static const String & struint()
Definition ValType.h:310
static const DComplex undefdcomplex
Definition ValType.h:283
static const String & strtable()
Definition ValType.h:342
static int isDefined(const Bool *value, const Bool *undef)
Check if a value is defined, i.e.
Definition ValType.h:569
static const String & strstring()
Definition ValType.h:334
this file contains all the compiler specific defines
Definition mainpage.dox:28
unsigned char uChar
Definition aipstype.h:47
short Short
Definition aipstype.h:48
unsigned int uInt
Definition aipstype.h:51
unsigned short uShort
Definition aipstype.h:49
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:50
bool Bool
Define the standard types used by Casacore.
Definition aipstype.h:42
LatticeExprNode value(const LatticeExprNode &expr)
This function returns the value of the expression without a mask.
const Bool True
Definition aipstype.h:43
char Char
Definition aipstype.h:46