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