casacore
StManColumn.h
Go to the documentation of this file.
1//# StManColumn.h: Base storage manager column class
2//# Copyright (C) 1994,1995,1996,1998,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 TABLES_STMANCOLUMN_H
29#define TABLES_STMANCOLUMN_H
30
31
32//# Includes
33#include <casacore/casa/aips.h>
34#include <casacore/tables/DataMan/StManColumnBase.h>
35#include <casacore/casa/Arrays/IPosition.h>
36
37namespace casacore { //# NAMESPACE CASACORE - BEGIN
38
39// <summary>
40// Base table column storage manager class
41// </summary>
42
43// <use visibility=local>
44
45// <reviewed reviewer="Gareth Hunt" date="94Nov17" tests="">
46// </reviewed>
47
48// <prerequisite>
49//# Classes you should understand before using this one.
50// <li> DataManagerColumn
51// </prerequisite>
52
53// <etymology>
54// StManColumn handles a column for a storage manager.
55// </etymology>
56
57// <synopsis>
58// StManColumn is the old storage manager base class which has been replaced
59// by StManColumnBase.
60// However, the class still exists for backward compatibility for external storage
61// managers (such as LofarStMan) that do not derive from StManColumnBase yet.
62// It also maps the new get/put functions taking a rownr_t to the old
63// functions taking a uInt rownr.
64// </synopsis>
65
66// <motivation>
67// Provide backward compatibility for external storage managers.
68// </motivation>
69
70// <todo asof="$DATE:$">
71//# A List of bugs, limitations, extensions or planned refinements.
72// </todo>
73
74
76{
77public:
78
79 // Default constructor.
82 {}
83
84 virtual ~StManColumn();
85
86 // Set the shape of an (variable-shaped) array in the given row.
87 // By default it throws a "not possible" exception.
88 virtual void setShape (rownr_t rownr, const IPosition& shape);
89 virtual void setShape (uInt rownr, const IPosition& shape);
90
91 // Set the shape and tile shape of an (variable-shaped) array
92 // in the given row.
93 // By default it ignores the tile shape (thus only sets the shape).
94 virtual void setShapeTiled (rownr_t rownr, const IPosition& shape,
95 const IPosition& tileShape);
96 virtual void setShapeTiled (uInt rownr, const IPosition& shape,
97 const IPosition& tileShape);
98
99 // Is the value shape defined in the given row?
100 // By default it returns True.
101 virtual Bool isShapeDefined (rownr_t rownr);
102 virtual Bool isShapeDefined (uInt rownr);
103
104 // Get the dimensionality of the item in the given row.
105 // By default it returns shape(rownr).nelements().
106 virtual uInt ndim (rownr_t rownr);
107 virtual uInt ndim (uInt rownr);
108
109 // Get the shape of the item in the given row.
110 // By default it returns a zero-length IPosition (for a scalar value).
111 virtual IPosition shape (rownr_t rownr);
112 virtual IPosition shape (uInt rownr);
113
114 // Get the tile shape of the item in the given row.
115 // By default it returns a zero-length IPosition.
116 virtual IPosition tileShape (rownr_t rownr);
117 virtual IPosition tileShape (uInt rownr);
118
119
120 // Get the scalar value in the given row.
121 // <group>
122 virtual void getBool (rownr_t rownr, Bool* dataPtr);
123 virtual void getuChar (rownr_t rownr, uChar* dataPtr);
124 virtual void getShort (rownr_t rownr, Short* dataPtr);
125 virtual void getuShort (rownr_t rownr, uShort* dataPtr);
126 virtual void getInt (rownr_t rownr, Int* dataPtr);
127 virtual void getuInt (rownr_t rownr, uInt* dataPtr);
128 virtual void getfloat (rownr_t rownr, float* dataPtr);
129 virtual void getdouble (rownr_t rownr, double* dataPtr);
130 virtual void getComplex (rownr_t rownr, Complex* dataPtr);
131 virtual void getDComplex (rownr_t rownr, DComplex* dataPtr);
132 virtual void getString (rownr_t rownr, String* dataPtr);
133 // </group>
134
135 // Put the scalar value in the given row.
136 // <group>
137 virtual void putBool (rownr_t rownr, const Bool* dataPtr);
138 virtual void putuChar (rownr_t rownr, const uChar* dataPtr);
139 virtual void putShort (rownr_t rownr, const Short* dataPtr);
140 virtual void putuShort (rownr_t rownr, const uShort* dataPtr);
141 virtual void putInt (rownr_t rownr, const Int* dataPtr);
142 virtual void putuInt (rownr_t rownr, const uInt* dataPtr);
143 virtual void putfloat (rownr_t rownr, const float* dataPtr);
144 virtual void putdouble (rownr_t rownr, const double* dataPtr);
145 virtual void putComplex (rownr_t rownr, const Complex* dataPtr);
146 virtual void putDComplex (rownr_t rownr, const DComplex* dataPtr);
147 virtual void putString (rownr_t rownr, const String* dataPtr);
148 // </group>
149
150 // Get all scalar values in the column.
151 // The argument dataPtr is in fact a Vector<T>&, but an ArrayBase&
152 // is needed to be generic.
153 // The vector pointed to by dataPtr has to have the correct length
154 // (which is guaranteed by the ScalarColumn getColumn function).
155 // The default implementation calls the appropriate getScalarColumnXXV.
156 virtual void getScalarColumnV (ArrayBase& dataPtr);
157
158 // Put all scalar values in the column.
159 // The argument dataPtr is in fact a const Vector<T>&, but a const ArrayBase&
160 // is needed to be generic.
161 // The vector pointed to by dataPtr has to have the correct length
162 // (which is guaranteed by the ScalarColumn putColumn function).
163 // The default implementation calls the appropriate putScalarColumnXXV.
164 virtual void putScalarColumnV (const ArrayBase& dataPtr);
165
166 // Get some scalar values in the column.
167 // The argument dataPtr is in fact a Vector<T>&, but an ArrayBase&
168 // is needed to be generic.
169 // The vector pointed to by dataPtr has to have the correct length
170 // (which is guaranteed by the ScalarColumn getColumn function).
171 // The default implementation calls the appropriate getScalarColumnCellsXXV.
172 virtual void getScalarColumnCellsV (const RefRows& rownrs,
173 ArrayBase& dataPtr);
174
175 // Put some scalar values in the column.
176 // The argument dataPtr is in fact a const Vector<T>&, but a const ArrayBase&
177 // is needed to be generic.
178 // The vector pointed to by dataPtr has to have the correct length
179 // (which is guaranteed by the ScalarColumn getColumn function).
180 // The default implementation calls the appropriate putScalarColumnCellsXXV.
181 virtual void putScalarColumnCellsV (const RefRows& rownrs,
182 const ArrayBase& dataPtr);
183
184 // Get the array value in the given row.
185 // The argument dataPtr is in fact an Array<T>&, but a ArrayBase&
186 // is needed to be generic.
187 // The array pointed to by dataPtr has to have the correct shape
188 // (which is guaranteed by the ArrayColumn get function).
189 // The default implementation calls the appropriate getArrayXXV.
190 virtual void getArrayV (rownr_t rownr, ArrayBase& dataPtr);
191
192 // Put the array value into the given row.
193 // The argument dataPtr is in fact a const Array<T>&, but a const ArrayBase&
194 // is needed to be generic.
195 // The array pointed to by dataPtr has to have the correct shape
196 // (which is guaranteed by the ArrayColumn put function).
197 // The default implementation calls the appropriate putArrayXXV.
198 virtual void putArrayV (rownr_t rownr, const ArrayBase& dataPtr);
199
200 // Get all array values in the column.
201 // The argument dataPtr is in fact an Array<T>&, but a ArrayBase&
202 // is needed to be generic.
203 // The vector pointed to by dataPtr has to have the correct length
204 // (which is guaranteed by the ArrayColumn getColumn function).
205 // The default implementation calls the appropriate getArrayColumnXXV.
206 virtual void getArrayColumnV (ArrayBase& dataPtr);
207
208 // Put all array values in the column.
209 // The argument dataPtr is in fact a const Array<T>&, but a const ArrayBase&
210 // is needed to be generic.
211 // The vector pointed to by dataPtr has to have the correct length
212 // (which is guaranteed by the ArrayColumn putColumn function).
213 // The default implementation calls the appropriate putArrayColumnXXV.
214 virtual void putArrayColumnV (const ArrayBase& dataPtr);
215
216 // Get some array values in the column.
217 // The argument dataPtr is in fact an Array<T>&, but a ArrayBase&
218 // is needed to be generic.
219 // The vector pointed to by dataPtr has to have the correct length
220 // (which is guaranteed by the ArrayColumn getColumn function).
221 // The default implementation calls the appropriate getArrayColumnCellsXXV.
222 virtual void getArrayColumnCellsV (const RefRows& rownrs,
223 ArrayBase& dataPtr);
224
225 // Put some array values in the column.
226 // The argument dataPtr is in fact an const Array<T>&, but a const ArrayBase&
227 // is needed to be generic.
228 // The vector pointed to by dataPtr has to have the correct length
229 // (which is guaranteed by the ArrayColumn getColumn function).
230 // The default implementation calls the appropriate putArrayColumnCellsXXV.
231 virtual void putArrayColumnCellsV (const RefRows& rownrs,
232 const ArrayBase& dataPtr);
233
234 // Get a section of the array in the given row.
235 // The argument dataPtr is in fact an Array<T>&, but a ArrayBase&
236 // is needed to be generic.
237 // The array pointed to by dataPtr has to have the correct shape
238 // (which is guaranteed by the ArrayColumn getSlice function).
239 // The default implementation calls the appropriate getSliceXXV.
240 virtual void getSliceV (rownr_t rownr, const Slicer& slicer,
241 ArrayBase& dataPtr);
242
243 // Put into a section of the array in the given row.
244 // The argument dataPtr is in fact a const Array<T>&, but a const ArrayBase&
245 // is needed to be generic.
246 // The array pointed to by dataPtr has to have the correct shape
247 // (which is guaranteed by the ArrayColumn putSlice function).
248 // The default implementation calls the appropriate putSliceXXV.
249 virtual void putSliceV (rownr_t rownr, const Slicer& slicer,
250 const ArrayBase& dataPtr);
251
252 // Get a section of all arrays in the column.
253 // The argument dataPtr is in fact an Array<T>&, but a ArrayBase&
254 // is needed to be generic.
255 // The array pointed to by dataPtr has to have the correct shape
256 // (which is guaranteed by the ArrayColumn getColumn function).
257 // The default implementation calls the appropriate getColumnSliceXXV.
258 virtual void getColumnSliceV (const Slicer& slicer, ArrayBase& dataPtr);
259
260 // Put into a section of all arrays in the column.
261 // The argument dataPtr is in fact a const Array<T>&, but a const ArrayBase&
262 // is needed to be generic.
263 // The array pointed to by dataPtr has to have the correct shape
264 // (which is guaranteed by the ArrayColumn putColumn function).
265 // The default implementation calls the appropriate putColumnSliceXXV.
266 virtual void putColumnSliceV (const Slicer& slicer, const ArrayBase& dataPtr);
267
268 // Get a section of some arrays in the column.
269 // The argument dataPtr is in fact an Array<T>&, but a ArrayBase&
270 // is needed to be generic.
271 // The array pointed to by dataPtr has to have the correct shape
272 // (which is guaranteed by the ArrayColumn getColumn function).
273 // The default implementation calls the appropriate getColumnSliceCellsXXV.
274 virtual void getColumnSliceCellsV (const RefRows& rownrs,
275 const Slicer& slicer, ArrayBase& dataPtr);
276
277 // Put into a section of some arrays in the column.
278 // The argument dataPtr is in fact a const Array<T>&, but a const ArrayBase&
279 // is needed to be generic.
280 // The array pointed to by dataPtr has to have the correct shape
281 // (which is guaranteed by the ArrayColumn putColumn function).
282 // The default implementation calls the appropriate putColumnSliceCellsXXV.
283 virtual void putColumnSliceCellsV (const RefRows& rownrs,
284 const Slicer& slicer,
285 const ArrayBase& dataPtr);
286
287
288private:
289 // The object cannot be copied.
291
292 // The object cannot be assigned to.
294
295 // Throw an "invalid operation" exception for the default
296 // implementation of getArray.
297 void throwInvalidOp(const String &op) const;
298
299protected:
300 // Get the scalar value in the given row.
301 // <group>
302 virtual void getBoolV (uInt rownr, Bool* dataPtr);
303 virtual void getuCharV (uInt rownr, uChar* dataPtr);
304 virtual void getShortV (uInt rownr, Short* dataPtr);
305 virtual void getuShortV (uInt rownr, uShort* dataPtr);
306 virtual void getIntV (uInt rownr, Int* dataPtr);
307 virtual void getuIntV (uInt rownr, uInt* dataPtr);
308 virtual void getfloatV (uInt rownr, float* dataPtr);
309 virtual void getdoubleV (uInt rownr, double* dataPtr);
310 virtual void getComplexV (uInt rownr, Complex* dataPtr);
311 virtual void getDComplexV (uInt rownr, DComplex* dataPtr);
312 virtual void getStringV (uInt rownr, String* dataPtr);
313 // </group>
314
315 // Put the scalar value in the given row.
316 // <group>
317 virtual void putBoolV (uInt rownr, const Bool* dataPtr);
318 virtual void putuCharV (uInt rownr, const uChar* dataPtr);
319 virtual void putShortV (uInt rownr, const Short* dataPtr);
320 virtual void putuShortV (uInt rownr, const uShort* dataPtr);
321 virtual void putIntV (uInt rownr, const Int* dataPtr);
322 virtual void putuIntV (uInt rownr, const uInt* dataPtr);
323 virtual void putfloatV (uInt rownr, const float* dataPtr);
324 virtual void putdoubleV (uInt rownr, const double* dataPtr);
325 virtual void putComplexV (uInt rownr, const Complex* dataPtr);
326 virtual void putDComplexV (uInt rownr, const DComplex* dataPtr);
327 virtual void putStringV (uInt rownr, const String* dataPtr);
328 // </group>
329
330 // Get the scalar values in the entire column.
331 // The buffer pointed to by dataPtr has to have the correct length.
332 // (which is guaranteed by the ScalarColumn getColumn function).
333 // The default implementations calls DataManagerColumn::getScalarColumnBase.
334 // <group>
335 virtual void getScalarColumnBoolV (Vector<Bool>* dataPtr);
336 virtual void getScalarColumnuCharV (Vector<uChar>* dataPtr);
337 virtual void getScalarColumnShortV (Vector<Short>* dataPtr);
338 virtual void getScalarColumnuShortV (Vector<uShort>* dataPtr);
339 virtual void getScalarColumnIntV (Vector<Int>* dataPtr);
340 virtual void getScalarColumnuIntV (Vector<uInt>* dataPtr);
341 virtual void getScalarColumnInt64V (Vector<Int64>* dataPtr);
342 virtual void getScalarColumnfloatV (Vector<float>* dataPtr);
343 virtual void getScalarColumndoubleV (Vector<double>* dataPtr);
346 virtual void getScalarColumnStringV (Vector<String>* dataPtr);
347 // </group>
348
349 // Put the scalar values into the entire column.
350 // The buffer pointed to by dataPtr has to have the correct length.
351 // (which is guaranteed by the ScalarColumn putColumn function).
352 // The default implementations calls DataManagerColumn::putScalarColumnBase.
353 // <group>
354 virtual void putScalarColumnBoolV (const Vector<Bool>* dataPtr);
355 virtual void putScalarColumnuCharV (const Vector<uChar>* dataPtr);
356 virtual void putScalarColumnShortV (const Vector<Short>* dataPtr);
357 virtual void putScalarColumnuShortV (const Vector<uShort>* dataPtr);
358 virtual void putScalarColumnIntV (const Vector<Int>* dataPtr);
359 virtual void putScalarColumnuIntV (const Vector<uInt>* dataPtr);
360 virtual void putScalarColumnInt64V (const Vector<Int64>* dataPtr);
361 virtual void putScalarColumnfloatV (const Vector<float>* dataPtr);
362 virtual void putScalarColumndoubleV (const Vector<double>* dataPtr);
363 virtual void putScalarColumnComplexV (const Vector<Complex>* dataPtr);
364 virtual void putScalarColumnDComplexV (const Vector<DComplex>* dataPtr);
365 virtual void putScalarColumnStringV (const Vector<String>* dataPtr);
366 // </group>
367
368 // Get the scalar values in some cells of the column.
369 // The buffer pointed to by dataPtr has to have the correct length.
370 // (which is guaranteed by the ScalarColumn getColumnCells function).
371 // The default implementations call DataManagerColumn::getScalarColumnCellsBase.
372 // <group>
373 virtual void getScalarColumnCellsBoolV (const RefRows& rownrs,
374 Vector<Bool>* dataPtr);
375 virtual void getScalarColumnCellsuCharV (const RefRows& rownrs,
376 Vector<uChar>* dataPtr);
377 virtual void getScalarColumnCellsShortV (const RefRows& rownrs,
378 Vector<Short>* dataPtr);
379 virtual void getScalarColumnCellsuShortV (const RefRows& rownrs,
380 Vector<uShort>* dataPtr);
381 virtual void getScalarColumnCellsIntV (const RefRows& rownrs,
382 Vector<Int>* dataPtr);
383 virtual void getScalarColumnCellsuIntV (const RefRows& rownrs,
384 Vector<uInt>* dataPtr);
385 virtual void getScalarColumnCellsInt64V (const RefRows& rownrs,
386 Vector<Int64>* dataPtr);
387 virtual void getScalarColumnCellsfloatV (const RefRows& rownrs,
388 Vector<float>* dataPtr);
389 virtual void getScalarColumnCellsdoubleV (const RefRows& rownrs,
390 Vector<double>* dataPtr);
391 virtual void getScalarColumnCellsComplexV (const RefRows& rownrs,
392 Vector<Complex>* dataPtr);
393 virtual void getScalarColumnCellsDComplexV (const RefRows& rownrs,
394 Vector<DComplex>* dataPtr);
395 virtual void getScalarColumnCellsStringV (const RefRows& rownrs,
396 Vector<String>* dataPtr);
397 // </group>
398
399 // Put the scalar values into some cells of the column.
400 // The buffer pointed to by dataPtr has to have the correct length.
401 // (which is guaranteed by the ScalarColumn putColumnCells function).
402 // The default implementations call DataManagerColumn::putScalarColumnCellsBase.
403 // <group>
404 virtual void putScalarColumnCellsBoolV (const RefRows& rownrs,
405 const Vector<Bool>* dataPtr);
406 virtual void putScalarColumnCellsuCharV (const RefRows& rownrs,
407 const Vector<uChar>* dataPtr);
408 virtual void putScalarColumnCellsShortV (const RefRows& rownrs,
409 const Vector<Short>* dataPtr);
410 virtual void putScalarColumnCellsuShortV (const RefRows& rownrs,
411 const Vector<uShort>* dataPtr);
412 virtual void putScalarColumnCellsIntV (const RefRows& rownrs,
413 const Vector<Int>* dataPtr);
414 virtual void putScalarColumnCellsuIntV (const RefRows& rownrs,
415 const Vector<uInt>* dataPtr);
416 virtual void putScalarColumnCellsInt64V (const RefRows& rownrs,
417 const Vector<Int64>* dataPtr);
418 virtual void putScalarColumnCellsfloatV (const RefRows& rownrs,
419 const Vector<float>* dataPtr);
420 virtual void putScalarColumnCellsdoubleV (const RefRows& rownrs,
421 const Vector<double>* dataPtr);
422 virtual void putScalarColumnCellsComplexV (const RefRows& rownrs,
423 const Vector<Complex>* dataPtr);
424 virtual void putScalarColumnCellsDComplexV (const RefRows& rownrs,
425 const Vector<DComplex>* dataPtr);
426 virtual void putScalarColumnCellsStringV (const RefRows& rownrs,
427 const Vector<String>* dataPtr);
428 // </group>
429
430 // Get the array value in the given row.
431 // The array pointed to by dataPtr has to have the correct length
432 // (which is guaranteed by the ArrayColumn get function).
433 // The default implementations throw an exception.
434 // <group>
435 virtual void getArrayBoolV (uInt rownr, Array<Bool>* dataPtr);
436 virtual void getArrayuCharV (uInt rownr, Array<uChar>* dataPtr);
437 virtual void getArrayShortV (uInt rownr, Array<Short>* dataPtr);
438 virtual void getArrayuShortV (uInt rownr, Array<uShort>* dataPtr);
439 virtual void getArrayIntV (uInt rownr, Array<Int>* dataPtr);
440 virtual void getArrayuIntV (uInt rownr, Array<uInt>* dataPtr);
441 virtual void getArrayInt64V (uInt rownr, Array<Int64>* dataPtr);
442 virtual void getArrayfloatV (uInt rownr, Array<float>* dataPtr);
443 virtual void getArraydoubleV (uInt rownr, Array<double>* dataPtr);
444 virtual void getArrayComplexV (uInt rownr, Array<Complex>* dataPtr);
445 virtual void getArrayDComplexV (uInt rownr, Array<DComplex>* dataPtr);
446 virtual void getArrayStringV (uInt rownr, Array<String>* dataPtr);
447 // </group>
448
449 // Put the array value into the given row.
450 // The buffer pointed to by dataPtr has to have the correct length
451 // (which is guaranteed by the ArrayColumn put function).
452 // The default implementations throw an exception.
453 // <group>
454 virtual void putArrayBoolV (uInt rownr,
455 const Array<Bool>* dataPtr);
456 virtual void putArrayuCharV (uInt rownr,
457 const Array<uChar>* dataPtr);
458 virtual void putArrayShortV (uInt rownr,
459 const Array<Short>* dataPtr);
460 virtual void putArrayuShortV (uInt rownr,
461 const Array<uShort>* dataPtr);
462 virtual void putArrayIntV (uInt rownr,
463 const Array<Int>* dataPtr);
464 virtual void putArrayuIntV (uInt rownr,
465 const Array<uInt>* dataPtr);
466 virtual void putArrayInt64V (uInt rownr,
467 const Array<Int64>* dataPtr);
468 virtual void putArrayfloatV (uInt rownr,
469 const Array<float>* dataPtr);
470 virtual void putArraydoubleV (uInt rownr,
471 const Array<double>* dataPtr);
472 virtual void putArrayComplexV (uInt rownr,
473 const Array<Complex>* dataPtr);
474 virtual void putArrayDComplexV (uInt rownr,
475 const Array<DComplex>* dataPtr);
476 virtual void putArrayStringV (uInt rownr,
477 const Array<String>* dataPtr);
478 // </group>
479
480 // Get the array values in the entire column.
481 // The buffer pointed to by dataPtr has to have the correct length.
482 // (which is guaranteed by the ArrayColumn getColumn function).
483 // The default implementations call DataManagerColumn::getArrayColumnBase.
484 // <group>
485 virtual void getArrayColumnBoolV (Array<Bool>* dataPtr);
486 virtual void getArrayColumnuCharV (Array<uChar>* dataPtr);
487 virtual void getArrayColumnShortV (Array<Short>* dataPtr);
488 virtual void getArrayColumnuShortV (Array<uShort>* dataPtr);
489 virtual void getArrayColumnIntV (Array<Int>* dataPtr);
490 virtual void getArrayColumnuIntV (Array<uInt>* dataPtr);
491 virtual void getArrayColumnInt64V (Array<Int64>* dataPtr);
492 virtual void getArrayColumnfloatV (Array<float>* dataPtr);
493 virtual void getArrayColumndoubleV (Array<double>* dataPtr);
494 virtual void getArrayColumnComplexV (Array<Complex>* dataPtr);
496 virtual void getArrayColumnStringV (Array<String>* dataPtr);
497 // </group>
498
499 // Put the array values into the entire column.
500 // The buffer pointed to by dataPtr has to have the correct length.
501 // (which is guaranteed by the ArrayColumn putColumn function).
502 // The default implementations call DataManagerColumn::putArrayColumnBase.
503 // <group>
504 virtual void putArrayColumnBoolV (const Array<Bool>* dataPtr);
505 virtual void putArrayColumnuCharV (const Array<uChar>* dataPtr);
506 virtual void putArrayColumnShortV (const Array<Short>* dataPtr);
507 virtual void putArrayColumnuShortV (const Array<uShort>* dataPtr);
508 virtual void putArrayColumnIntV (const Array<Int>* dataPtr);
509 virtual void putArrayColumnuIntV (const Array<uInt>* dataPtr);
510 virtual void putArrayColumnInt64V (const Array<Int64>* dataPtr);
511 virtual void putArrayColumnfloatV (const Array<float>* dataPtr);
512 virtual void putArrayColumndoubleV (const Array<double>* dataPtr);
513 virtual void putArrayColumnComplexV (const Array<Complex>* dataPtr);
514 virtual void putArrayColumnDComplexV (const Array<DComplex>* dataPtr);
515 virtual void putArrayColumnStringV (const Array<String>* dataPtr);
516 // </group>
517
518 // Get the array values in some cells of the column.
519 // The buffer pointed to by dataPtr has to have the correct length.
520 // (which is guaranteed by the ArrayColumn getColumnCells function).
521 // The default implementations call DataManagerColumn::getArrayColumnCellsBase.
522 // <group>
523 virtual void getArrayColumnCellsBoolV (const RefRows& rownrs,
524 Array<Bool>* dataPtr);
525 virtual void getArrayColumnCellsuCharV (const RefRows& rownrs,
526 Array<uChar>* dataPtr);
527 virtual void getArrayColumnCellsShortV (const RefRows& rownrs,
528 Array<Short>* dataPtr);
529 virtual void getArrayColumnCellsuShortV (const RefRows& rownrs,
530 Array<uShort>* dataPtr);
531 virtual void getArrayColumnCellsIntV (const RefRows& rownrs,
532 Array<Int>* dataPtr);
533 virtual void getArrayColumnCellsuIntV (const RefRows& rownrs,
534 Array<uInt>* dataPtr);
535 virtual void getArrayColumnCellsInt64V (const RefRows& rownrs,
536 Array<Int64>* dataPtr);
537 virtual void getArrayColumnCellsfloatV (const RefRows& rownrs,
538 Array<float>* dataPtr);
539 virtual void getArrayColumnCellsdoubleV (const RefRows& rownrs,
540 Array<double>* dataPtr);
541 virtual void getArrayColumnCellsComplexV (const RefRows& rownrs,
542 Array<Complex>* dataPtr);
543 virtual void getArrayColumnCellsDComplexV (const RefRows& rownrs,
544 Array<DComplex>* dataPtr);
545 virtual void getArrayColumnCellsStringV (const RefRows& rownrs,
546 Array<String>* dataPtr);
547 // </group>
548
549 // Put the array values into some cells of the column.
550 // The buffer pointed to by dataPtr has to have the correct length.
551 // (which is guaranteed by the ArrayColumn putColumnCells function).
552 // The default implementations call DataManagerColumn::putArrayColumnCellsBase.
553 // <group>
554 virtual void putArrayColumnCellsBoolV (const RefRows& rownrs,
555 const Array<Bool>* dataPtr);
556 virtual void putArrayColumnCellsuCharV (const RefRows& rownrs,
557 const Array<uChar>* dataPtr);
558 virtual void putArrayColumnCellsShortV (const RefRows& rownrs,
559 const Array<Short>* dataPtr);
560 virtual void putArrayColumnCellsuShortV (const RefRows& rownrs,
561 const Array<uShort>* dataPtr);
562 virtual void putArrayColumnCellsIntV (const RefRows& rownrs,
563 const Array<Int>* dataPtr);
564 virtual void putArrayColumnCellsuIntV (const RefRows& rownrs,
565 const Array<uInt>* dataPtr);
566 virtual void putArrayColumnCellsInt64V (const RefRows& rownrs,
567 const Array<Int64>* dataPtr);
568 virtual void putArrayColumnCellsfloatV (const RefRows& rownrs,
569 const Array<float>* dataPtr);
570 virtual void putArrayColumnCellsdoubleV (const RefRows& rownrs,
571 const Array<double>* dataPtr);
572 virtual void putArrayColumnCellsComplexV (const RefRows& rownrs,
573 const Array<Complex>* dataPtr);
574 virtual void putArrayColumnCellsDComplexV (const RefRows& rownrs,
575 const Array<DComplex>* dataPtr);
576 virtual void putArrayColumnCellsStringV (const RefRows& rownrs,
577 const Array<String>* dataPtr);
578 // </group>
579
580 // Get the array value in the given row.
581 // The array pointed to by dataPtr has to have the correct length
582 // (which is guaranteed by the ArrayColumn getSlice function).
583 // The default implementations call DataManagerColumn::getSliceBase.
584 // <group>
585 virtual void getSliceBoolV (uInt rownr, const Slicer& ns,
586 Array<Bool>* dataPtr);
587 virtual void getSliceuCharV (uInt rownr, const Slicer& ns,
588 Array<uChar>* dataPtr);
589 virtual void getSliceShortV (uInt rownr, const Slicer& ns,
590 Array<Short>* dataPtr);
591 virtual void getSliceuShortV (uInt rownr, const Slicer& ns,
592 Array<uShort>* dataPtr);
593 virtual void getSliceIntV (uInt rownr, const Slicer& ns,
594 Array<Int>* dataPtr);
595 virtual void getSliceuIntV (uInt rownr, const Slicer& ns,
596 Array<uInt>* dataPtr);
597 virtual void getSliceInt64V (uInt rownr, const Slicer& ns,
598 Array<Int64>* dataPtr);
599 virtual void getSlicefloatV (uInt rownr, const Slicer& ns,
600 Array<float>* dataPtr);
601 virtual void getSlicedoubleV (uInt rownr, const Slicer& ns,
602 Array<double>* dataPtr);
603 virtual void getSliceComplexV (uInt rownr, const Slicer& ns,
604 Array<Complex>* dataPtr);
605 virtual void getSliceDComplexV (uInt rownr, const Slicer& ns,
606 Array<DComplex>* dataPtr);
607 virtual void getSliceStringV (uInt rownr, const Slicer& ns,
608 Array<String>* dataPtr);
609 // </group>
610
611 // Put the array value into the given row.
612 // The buffer pointed to by dataPtr has to have the correct length
613 // (which is guaranteed by the ArrayColumn putSlice function).
614 // The default implementations call DataManagerColumn::putSliceBase.
615 // <group>
616 virtual void putSliceBoolV (uInt rownr, const Slicer& ns,
617 const Array<Bool>* dataPtr);
618 virtual void putSliceuCharV (uInt rownr, const Slicer& ns,
619 const Array<uChar>* dataPtr);
620 virtual void putSliceShortV (uInt rownr, const Slicer& ns,
621 const Array<Short>* dataPtr);
622 virtual void putSliceuShortV (uInt rownr, const Slicer& ns,
623 const Array<uShort>* dataPtr);
624 virtual void putSliceIntV (uInt rownr, const Slicer& ns,
625 const Array<Int>* dataPtr);
626 virtual void putSliceuIntV (uInt rownr, const Slicer& ns,
627 const Array<uInt>* dataPtr);
628 virtual void putSliceInt64V (uInt rownr, const Slicer& ns,
629 const Array<Int64>* dataPtr);
630 virtual void putSlicefloatV (uInt rownr, const Slicer& ns,
631 const Array<float>* dataPtr);
632 virtual void putSlicedoubleV (uInt rownr, const Slicer& ns,
633 const Array<double>* dataPtr);
634 virtual void putSliceComplexV (uInt rownr, const Slicer& ns,
635 const Array<Complex>* dataPtr);
636 virtual void putSliceDComplexV (uInt rownr, const Slicer& ns,
637 const Array<DComplex>* dataPtr);
638 virtual void putSliceStringV (uInt rownr, const Slicer& ns,
639 const Array<String>* dataPtr);
640 // </group>
641
642 // Get the array values in the entire column.
643 // The buffer pointed to by dataPtr has to have the correct length.
644 // (which is guaranteed by the ArrayColumn getColumn function).
645 // The default implementations call DataManagerColumn::getColumnSliceBase.
646 // <group>
647 virtual void getColumnSliceBoolV (const Slicer& ns,
648 Array<Bool>* dataPtr);
649 virtual void getColumnSliceuCharV (const Slicer& ns,
650 Array<uChar>* dataPtr);
651 virtual void getColumnSliceShortV (const Slicer& ns,
652 Array<Short>* dataPtr);
653 virtual void getColumnSliceuShortV (const Slicer& ns,
654 Array<uShort>* dataPtr);
655 virtual void getColumnSliceIntV (const Slicer& ns,
656 Array<Int>* dataPtr);
657 virtual void getColumnSliceuIntV (const Slicer& ns,
658 Array<uInt>* dataPtr);
659 virtual void getColumnSliceInt64V (const Slicer& ns,
660 Array<Int64>* dataPtr);
661 virtual void getColumnSlicefloatV (const Slicer& ns,
662 Array<float>* dataPtr);
663 virtual void getColumnSlicedoubleV (const Slicer& ns,
664 Array<double>* dataPtr);
665 virtual void getColumnSliceComplexV (const Slicer& ns,
666 Array<Complex>* dataPtr);
667 virtual void getColumnSliceDComplexV (const Slicer& ns,
668 Array<DComplex>* dataPtr);
669 virtual void getColumnSliceStringV (const Slicer& ns,
670 Array<String>* dataPtr);
671 // </group>
672
673 // Put the array values into the entire column.
674 // The buffer pointed to by dataPtr has to have the correct length.
675 // (which is guaranteed by the ArrayColumn putColumn function).
676 // The default implementations call DataManagerColumn::putColumnSliceBase.
677 // <group>
678 virtual void putColumnSliceBoolV (const Slicer& ns,
679 const Array<Bool>* dataPtr);
680 virtual void putColumnSliceuCharV (const Slicer& ns,
681 const Array<uChar>* dataPtr);
682 virtual void putColumnSliceShortV (const Slicer& ns,
683 const Array<Short>* dataPtr);
684 virtual void putColumnSliceuShortV (const Slicer& ns,
685 const Array<uShort>* dataPtr);
686 virtual void putColumnSliceIntV (const Slicer& ns,
687 const Array<Int>* dataPtr);
688 virtual void putColumnSliceuIntV (const Slicer& ns,
689 const Array<uInt>* dataPtr);
690 virtual void putColumnSliceInt64V (const Slicer& ns,
691 const Array<Int64>* dataPtr);
692 virtual void putColumnSlicefloatV (const Slicer& ns,
693 const Array<float>* dataPtr);
694 virtual void putColumnSlicedoubleV (const Slicer& ns,
695 const Array<double>* dataPtr);
696 virtual void putColumnSliceComplexV (const Slicer& ns,
697 const Array<Complex>* dataPtr);
698 virtual void putColumnSliceDComplexV (const Slicer& ns,
699 const Array<DComplex>* dataPtr);
700 virtual void putColumnSliceStringV (const Slicer& ns,
701 const Array<String>* dataPtr);
702 // </group>
703
704 // Get the array values in some cells of the column.
705 // The buffer pointed to by dataPtr has to have the correct length.
706 // (which is guaranteed by the ArrayColumn getColumnCells function).
707 // The default implementations call DataManagerColumn::getColumnSliceCellsBase.
708 // <group>
709 virtual void getColumnSliceCellsBoolV (const RefRows& rownrs,
710 const Slicer& ns,
711 Array<Bool>* dataPtr);
712 virtual void getColumnSliceCellsuCharV (const RefRows& rownrs,
713 const Slicer& ns,
714 Array<uChar>* dataPtr);
715 virtual void getColumnSliceCellsShortV (const RefRows& rownrs,
716 const Slicer& ns,
717 Array<Short>* dataPtr);
718 virtual void getColumnSliceCellsuShortV (const RefRows& rownrs,
719 const Slicer& ns,
720 Array<uShort>* dataPtr);
721 virtual void getColumnSliceCellsIntV (const RefRows& rownrs,
722 const Slicer& ns,
723 Array<Int>* dataPtr);
724 virtual void getColumnSliceCellsuIntV (const RefRows& rownrs,
725 const Slicer& ns,
726 Array<uInt>* dataPtr);
727 virtual void getColumnSliceCellsInt64V (const RefRows& rownrs,
728 const Slicer& ns,
729 Array<Int64>* dataPtr);
730 virtual void getColumnSliceCellsfloatV (const RefRows& rownrs,
731 const Slicer& ns,
732 Array<float>* dataPtr);
733 virtual void getColumnSliceCellsdoubleV (const RefRows& rownrs,
734 const Slicer& ns,
735 Array<double>* dataPtr);
736 virtual void getColumnSliceCellsComplexV (const RefRows& rownrs,
737 const Slicer& ns,
738 Array<Complex>* dataPtr);
739 virtual void getColumnSliceCellsDComplexV (const RefRows& rownrs,
740 const Slicer& ns,
741 Array<DComplex>* dataPtr);
742 virtual void getColumnSliceCellsStringV (const RefRows& rownrs,
743 const Slicer& ns,
744 Array<String>* dataPtr);
745 // </group>
746
747 // Put the array values into some cells of the column.
748 // The buffer pointed to by dataPtr has to have the correct length.
749 // (which is guaranteed by the ArrayColumn putColumnSlice function).
750 // The default implementations call DataManagerColumn::putColumnSliceCellsBase.
751 // <group>
752 virtual void putColumnSliceCellsBoolV (const RefRows& rownrs,
753 const Slicer& ns,
754 const Array<Bool>* dataPtr);
755 virtual void putColumnSliceCellsuCharV (const RefRows& rownrs,
756 const Slicer& ns,
757 const Array<uChar>* dataPtr);
758 virtual void putColumnSliceCellsShortV (const RefRows& rownrs,
759 const Slicer& ns,
760 const Array<Short>* dataPtr);
761 virtual void putColumnSliceCellsuShortV (const RefRows& rownrs,
762 const Slicer& ns,
763 const Array<uShort>* dataPtr);
764 virtual void putColumnSliceCellsIntV (const RefRows& rownrs,
765 const Slicer& ns,
766 const Array<Int>* dataPtr);
767 virtual void putColumnSliceCellsuIntV (const RefRows& rownrs,
768 const Slicer& ns,
769 const Array<uInt>* dataPtr);
770 virtual void putColumnSliceCellsInt64V (const RefRows& rownrs,
771 const Slicer& ns,
772 const Array<Int64>* dataPtr);
773 virtual void putColumnSliceCellsfloatV (const RefRows& rownrs,
774 const Slicer& ns,
775 const Array<float>* dataPtr);
776 virtual void putColumnSliceCellsdoubleV (const RefRows& rownrs,
777 const Slicer& ns,
778 const Array<double>* dataPtr);
779 virtual void putColumnSliceCellsComplexV (const RefRows& rownrs,
780 const Slicer& ns,
781 const Array<Complex>* dataPtr);
782 virtual void putColumnSliceCellsDComplexV (const RefRows& rownrs,
783 const Slicer& ns,
784 const Array<DComplex>* dataPtr);
785 virtual void putColumnSliceCellsStringV (const RefRows& rownrs,
786 const Slicer& ns,
787 const Array<String>* dataPtr);
788 // </group>
789};
790
791
792
793
794} //# NAMESPACE CASACORE - END
795
796#endif
Non-templated base class for templated Array class.
Definition: ArrayBase.h:73
virtual int dataType() const
Return the data type of the column.
virtual void putArrayColumnCellsShortV(const RefRows &rownrs, const Array< Short > *dataPtr)
virtual void getArrayColumnuShortV(Array< uShort > *dataPtr)
virtual void putuIntV(uInt rownr, const uInt *dataPtr)
virtual void putSliceShortV(uInt rownr, const Slicer &ns, const Array< Short > *dataPtr)
virtual void putSliceV(rownr_t rownr, const Slicer &slicer, const ArrayBase &dataPtr)
Put into a section of the array in the given row.
virtual void getColumnSliceCellsuShortV(const RefRows &rownrs, const Slicer &ns, Array< uShort > *dataPtr)
virtual void getScalarColumnDComplexV(Vector< DComplex > *dataPtr)
virtual void getArrayColumnShortV(Array< Short > *dataPtr)
virtual void putColumnSliceCellsBoolV(const RefRows &rownrs, const Slicer &ns, const Array< Bool > *dataPtr)
Put the array values into some cells of the column.
virtual uInt ndim(uInt rownr)
virtual void putArrayBoolV(uInt rownr, const Array< Bool > *dataPtr)
Put the array value into the given row.
virtual void getScalarColumnCellsuIntV(const RefRows &rownrs, Vector< uInt > *dataPtr)
virtual void getArrayInt64V(uInt rownr, Array< Int64 > *dataPtr)
virtual Bool isShapeDefined(uInt rownr)
virtual void getColumnSliceIntV(const Slicer &ns, Array< Int > *dataPtr)
virtual void putScalarColumnCellsuShortV(const RefRows &rownrs, const Vector< uShort > *dataPtr)
virtual void putSliceuShortV(uInt rownr, const Slicer &ns, const Array< uShort > *dataPtr)
virtual void putScalarColumnCellsDComplexV(const RefRows &rownrs, const Vector< DComplex > *dataPtr)
virtual void getArrayColumnCellsV(const RefRows &rownrs, ArrayBase &dataPtr)
Get some array values in the column.
virtual void putColumnSliceCellsuIntV(const RefRows &rownrs, const Slicer &ns, const Array< uInt > *dataPtr)
virtual void getScalarColumnCellsV(const RefRows &rownrs, ArrayBase &dataPtr)
Get some scalar values in the column.
virtual void getArrayColumnCellsInt64V(const RefRows &rownrs, Array< Int64 > *dataPtr)
virtual void getSliceuShortV(uInt rownr, const Slicer &ns, Array< uShort > *dataPtr)
virtual void getColumnSliceCellsInt64V(const RefRows &rownrs, const Slicer &ns, Array< Int64 > *dataPtr)
virtual void putString(rownr_t rownr, const String *dataPtr)
virtual void getuShortV(uInt rownr, uShort *dataPtr)
virtual void getScalarColumnCellsStringV(const RefRows &rownrs, Vector< String > *dataPtr)
virtual void getArrayBoolV(uInt rownr, Array< Bool > *dataPtr)
Get the array value in the given row.
virtual void putScalarColumnCellsuIntV(const RefRows &rownrs, const Vector< uInt > *dataPtr)
virtual void putSliceuIntV(uInt rownr, const Slicer &ns, const Array< uInt > *dataPtr)
virtual void putArrayColumnDComplexV(const Array< DComplex > *dataPtr)
virtual void putScalarColumnCellsfloatV(const RefRows &rownrs, const Vector< float > *dataPtr)
virtual void putArrayColumnCellsV(const RefRows &rownrs, const ArrayBase &dataPtr)
Put some array values in the column.
virtual void getArrayColumnCellsBoolV(const RefRows &rownrs, Array< Bool > *dataPtr)
Get the array values in some cells of the column.
virtual void getArrayColumnCellsuCharV(const RefRows &rownrs, Array< uChar > *dataPtr)
virtual void putArrayColumnfloatV(const Array< float > *dataPtr)
virtual void getScalarColumnComplexV(Vector< Complex > *dataPtr)
virtual void getArrayColumnV(ArrayBase &dataPtr)
Get all array values in the column.
virtual void getSliceIntV(uInt rownr, const Slicer &ns, Array< Int > *dataPtr)
virtual void putArrayColumnCellsfloatV(const RefRows &rownrs, const Array< float > *dataPtr)
virtual void getColumnSliceBoolV(const Slicer &ns, Array< Bool > *dataPtr)
Get the array values in the entire column.
virtual void putColumnSliceV(const Slicer &slicer, const ArrayBase &dataPtr)
Put into a section of all arrays in the column.
virtual void putArrayShortV(uInt rownr, const Array< Short > *dataPtr)
virtual void putdoubleV(uInt rownr, const double *dataPtr)
virtual void getArrayColumnCellsfloatV(const RefRows &rownrs, Array< float > *dataPtr)
virtual void putScalarColumnBoolV(const Vector< Bool > *dataPtr)
Put the scalar values into the entire column.
virtual void putuInt(rownr_t rownr, const uInt *dataPtr)
virtual void putColumnSliceCellsDComplexV(const RefRows &rownrs, const Slicer &ns, const Array< DComplex > *dataPtr)
virtual void getString(rownr_t rownr, String *dataPtr)
virtual void putColumnSliceCellsInt64V(const RefRows &rownrs, const Slicer &ns, const Array< Int64 > *dataPtr)
virtual void putArrayColumnuShortV(const Array< uShort > *dataPtr)
StManColumn & operator=(const StManColumn &)
The object cannot be assigned to.
virtual void getScalarColumndoubleV(Vector< double > *dataPtr)
virtual void putArrayColumnStringV(const Array< String > *dataPtr)
virtual void getColumnSliceV(const Slicer &slicer, ArrayBase &dataPtr)
Get a section of all arrays in the column.
virtual void getArrayDComplexV(uInt rownr, Array< DComplex > *dataPtr)
virtual void putColumnSliceCellsuCharV(const RefRows &rownrs, const Slicer &ns, const Array< uChar > *dataPtr)
virtual void putArrayStringV(uInt rownr, const Array< String > *dataPtr)
virtual void putColumnSliceCellsuShortV(const RefRows &rownrs, const Slicer &ns, const Array< uShort > *dataPtr)
virtual void getScalarColumnCellsIntV(const RefRows &rownrs, Vector< Int > *dataPtr)
virtual void putArrayColumnCellsuCharV(const RefRows &rownrs, const Array< uChar > *dataPtr)
virtual void getScalarColumnV(ArrayBase &dataPtr)
Get all scalar values in the column.
virtual void putScalarColumnCellsuCharV(const RefRows &rownrs, const Vector< uChar > *dataPtr)
virtual void getScalarColumnCellsBoolV(const RefRows &rownrs, Vector< Bool > *dataPtr)
Get the scalar values in some cells of the column.
virtual void putScalarColumnInt64V(const Vector< Int64 > *dataPtr)
virtual void putColumnSliceCellsComplexV(const RefRows &rownrs, const Slicer &ns, const Array< Complex > *dataPtr)
virtual void putArrayInt64V(uInt rownr, const Array< Int64 > *dataPtr)
virtual void getSliceBoolV(uInt rownr, const Slicer &ns, Array< Bool > *dataPtr)
Get the array value in the given row.
virtual void getColumnSliceCellsStringV(const RefRows &rownrs, const Slicer &ns, Array< String > *dataPtr)
virtual void getuChar(rownr_t rownr, uChar *dataPtr)
virtual IPosition tileShape(rownr_t rownr)
Get the tile shape of the item in the given row.
virtual void putShort(rownr_t rownr, const Short *dataPtr)
virtual void getColumnSliceComplexV(const Slicer &ns, Array< Complex > *dataPtr)
virtual void putArrayColumnCellsStringV(const RefRows &rownrs, const Array< String > *dataPtr)
virtual void getScalarColumnfloatV(Vector< float > *dataPtr)
virtual void putComplex(rownr_t rownr, const Complex *dataPtr)
virtual void getuInt(rownr_t rownr, uInt *dataPtr)
virtual void putScalarColumnComplexV(const Vector< Complex > *dataPtr)
virtual void putArrayColumnCellsuShortV(const RefRows &rownrs, const Array< uShort > *dataPtr)
virtual void getSliceV(rownr_t rownr, const Slicer &slicer, ArrayBase &dataPtr)
Get a section of the array in the given row.
virtual void getColumnSliceuShortV(const Slicer &ns, Array< uShort > *dataPtr)
virtual void putArrayDComplexV(uInt rownr, const Array< DComplex > *dataPtr)
virtual void putArrayColumnBoolV(const Array< Bool > *dataPtr)
Put the array values into the entire column.
virtual void putScalarColumnuIntV(const Vector< uInt > *dataPtr)
virtual void getDComplexV(uInt rownr, DComplex *dataPtr)
virtual uInt ndim(rownr_t rownr)
Get the dimensionality of the item in the given row.
virtual void getSlicedoubleV(uInt rownr, const Slicer &ns, Array< double > *dataPtr)
virtual void getSliceDComplexV(uInt rownr, const Slicer &ns, Array< DComplex > *dataPtr)
void throwInvalidOp(const String &op) const
Throw an "invalid operation" exception for the default implementation of getArray.
StManColumn(const StManColumn &)
The object cannot be copied.
virtual void getSliceShortV(uInt rownr, const Slicer &ns, Array< Short > *dataPtr)
virtual void getBoolV(uInt rownr, Bool *dataPtr)
Get the scalar value in the given row.
virtual void putArrayColumnCellsIntV(const RefRows &rownrs, const Array< Int > *dataPtr)
virtual void putArrayuShortV(uInt rownr, const Array< uShort > *dataPtr)
virtual void getColumnSliceuIntV(const Slicer &ns, Array< uInt > *dataPtr)
virtual void putfloat(rownr_t rownr, const float *dataPtr)
virtual void putfloatV(uInt rownr, const float *dataPtr)
virtual void putSliceIntV(uInt rownr, const Slicer &ns, const Array< Int > *dataPtr)
virtual void getArrayColumnCellsdoubleV(const RefRows &rownrs, Array< double > *dataPtr)
virtual void putColumnSliceCellsIntV(const RefRows &rownrs, const Slicer &ns, const Array< Int > *dataPtr)
virtual void getArrayColumnCellsStringV(const RefRows &rownrs, Array< String > *dataPtr)
virtual void putShortV(uInt rownr, const Short *dataPtr)
virtual IPosition shape(uInt rownr)
virtual Bool isShapeDefined(rownr_t rownr)
Is the value shape defined in the given row? By default it returns True.
virtual void putuChar(rownr_t rownr, const uChar *dataPtr)
virtual IPosition shape(rownr_t rownr)
Get the shape of the item in the given row.
virtual void putArrayColumnCellsdoubleV(const RefRows &rownrs, const Array< double > *dataPtr)
virtual void getSlicefloatV(uInt rownr, const Slicer &ns, Array< float > *dataPtr)
virtual void putArrayColumnShortV(const Array< Short > *dataPtr)
virtual void putSliceComplexV(uInt rownr, const Slicer &ns, const Array< Complex > *dataPtr)
virtual void getSliceuIntV(uInt rownr, const Slicer &ns, Array< uInt > *dataPtr)
virtual void getColumnSliceCellsIntV(const RefRows &rownrs, const Slicer &ns, Array< Int > *dataPtr)
virtual void getScalarColumnStringV(Vector< String > *dataPtr)
virtual void getInt(rownr_t rownr, Int *dataPtr)
virtual void putArrayuCharV(uInt rownr, const Array< uChar > *dataPtr)
virtual void getIntV(uInt rownr, Int *dataPtr)
virtual void putStringV(uInt rownr, const String *dataPtr)
virtual void putScalarColumnCellsInt64V(const RefRows &rownrs, const Vector< Int64 > *dataPtr)
virtual void getArrayuIntV(uInt rownr, Array< uInt > *dataPtr)
virtual void getArrayColumnInt64V(Array< Int64 > *dataPtr)
virtual void putArrayColumnuCharV(const Array< uChar > *dataPtr)
virtual void getStringV(uInt rownr, String *dataPtr)
virtual void putScalarColumnV(const ArrayBase &dataPtr)
Put all scalar values in the column.
virtual void getArrayColumnIntV(Array< Int > *dataPtr)
virtual void getColumnSliceCellsfloatV(const RefRows &rownrs, const Slicer &ns, Array< float > *dataPtr)
virtual void putSliceuCharV(uInt rownr, const Slicer &ns, const Array< uChar > *dataPtr)
virtual void getArrayfloatV(uInt rownr, Array< float > *dataPtr)
virtual void putArrayColumnCellsBoolV(const RefRows &rownrs, const Array< Bool > *dataPtr)
Put the array values into some cells of the column.
virtual void getScalarColumnIntV(Vector< Int > *dataPtr)
virtual void putArrayColumnComplexV(const Array< Complex > *dataPtr)
virtual void getArrayIntV(uInt rownr, Array< Int > *dataPtr)
virtual void getArrayColumnCellsuShortV(const RefRows &rownrs, Array< uShort > *dataPtr)
virtual void putSlicefloatV(uInt rownr, const Slicer &ns, const Array< float > *dataPtr)
virtual void getScalarColumnCellsdoubleV(const RefRows &rownrs, Vector< double > *dataPtr)
virtual void getScalarColumnuCharV(Vector< uChar > *dataPtr)
virtual void putSliceBoolV(uInt rownr, const Slicer &ns, const Array< Bool > *dataPtr)
Put the array value into the given row.
virtual void putSliceInt64V(uInt rownr, const Slicer &ns, const Array< Int64 > *dataPtr)
virtual void getfloat(rownr_t rownr, float *dataPtr)
StManColumn(int dataType)
Default constructor.
Definition: StManColumn.h:80
virtual void putDComplex(rownr_t rownr, const DComplex *dataPtr)
virtual void putuCharV(uInt rownr, const uChar *dataPtr)
virtual void getScalarColumnCellsDComplexV(const RefRows &rownrs, Vector< DComplex > *dataPtr)
virtual void putArraydoubleV(uInt rownr, const Array< double > *dataPtr)
virtual void setShape(uInt rownr, const IPosition &shape)
virtual void getColumnSliceCellsV(const RefRows &rownrs, const Slicer &slicer, ArrayBase &dataPtr)
Get a section of some arrays in the column.
virtual void putSliceDComplexV(uInt rownr, const Slicer &ns, const Array< DComplex > *dataPtr)
virtual void putSlicedoubleV(uInt rownr, const Slicer &ns, const Array< double > *dataPtr)
virtual void putColumnSliceuCharV(const Slicer &ns, const Array< uChar > *dataPtr)
virtual void getScalarColumnInt64V(Vector< Int64 > *dataPtr)
virtual void putArrayColumnCellsComplexV(const RefRows &rownrs, const Array< Complex > *dataPtr)
virtual void setShapeTiled(rownr_t rownr, const IPosition &shape, const IPosition &tileShape)
Set the shape and tile shape of an (variable-shaped) array in the given row.
virtual void putScalarColumnuCharV(const Vector< uChar > *dataPtr)
virtual void getSliceComplexV(uInt rownr, const Slicer &ns, Array< Complex > *dataPtr)
virtual void getArrayColumnuIntV(Array< uInt > *dataPtr)
virtual void getColumnSliceInt64V(const Slicer &ns, Array< Int64 > *dataPtr)
virtual void getScalarColumnCellsComplexV(const RefRows &rownrs, Vector< Complex > *dataPtr)
virtual void putArrayColumnV(const ArrayBase &dataPtr)
Put all array values in the column.
virtual void putComplexV(uInt rownr, const Complex *dataPtr)
virtual void putColumnSliceBoolV(const Slicer &ns, const Array< Bool > *dataPtr)
Put the array values into the entire column.
virtual void putScalarColumnCellsBoolV(const RefRows &rownrs, const Vector< Bool > *dataPtr)
Put the scalar values into some cells of the column.
virtual void getScalarColumnBoolV(Vector< Bool > *dataPtr)
Get the scalar values in the entire column.
virtual void getBool(rownr_t rownr, Bool *dataPtr)
Get the scalar value in the given row.
virtual void putInt(rownr_t rownr, const Int *dataPtr)
virtual void getColumnSlicedoubleV(const Slicer &ns, Array< double > *dataPtr)
virtual void putArrayColumnCellsuIntV(const RefRows &rownrs, const Array< uInt > *dataPtr)
virtual void getScalarColumnCellsuShortV(const RefRows &rownrs, Vector< uShort > *dataPtr)
virtual void putColumnSliceCellsStringV(const RefRows &rownrs, const Slicer &ns, const Array< String > *dataPtr)
virtual void putColumnSliceCellsV(const RefRows &rownrs, const Slicer &slicer, const ArrayBase &dataPtr)
Put into a section of some arrays in the column.
virtual void putArrayColumnInt64V(const Array< Int64 > *dataPtr)
virtual void getColumnSliceCellsShortV(const RefRows &rownrs, const Slicer &ns, Array< Short > *dataPtr)
virtual void setShape(rownr_t rownr, const IPosition &shape)
Set the shape of an (variable-shaped) array in the given row.
virtual void getColumnSliceStringV(const Slicer &ns, Array< String > *dataPtr)
virtual void putScalarColumnStringV(const Vector< String > *dataPtr)
virtual void putColumnSlicedoubleV(const Slicer &ns, const Array< double > *dataPtr)
virtual void putColumnSliceComplexV(const Slicer &ns, const Array< Complex > *dataPtr)
virtual void putArrayfloatV(uInt rownr, const Array< float > *dataPtr)
virtual void getArrayColumnComplexV(Array< Complex > *dataPtr)
virtual void getSliceuCharV(uInt rownr, const Slicer &ns, Array< uChar > *dataPtr)
virtual void putScalarColumnCellsStringV(const RefRows &rownrs, const Vector< String > *dataPtr)
virtual void putColumnSliceCellsfloatV(const RefRows &rownrs, const Slicer &ns, const Array< float > *dataPtr)
virtual void getColumnSliceCellsDComplexV(const RefRows &rownrs, const Slicer &ns, Array< DComplex > *dataPtr)
virtual void putSliceStringV(uInt rownr, const Slicer &ns, const Array< String > *dataPtr)
virtual void putBoolV(uInt rownr, const Bool *dataPtr)
Put the scalar value in the given row.
virtual void getArraydoubleV(uInt rownr, Array< double > *dataPtr)
virtual void getuCharV(uInt rownr, uChar *dataPtr)
virtual void putColumnSliceStringV(const Slicer &ns, const Array< String > *dataPtr)
virtual void getColumnSliceCellsComplexV(const RefRows &rownrs, const Slicer &ns, Array< Complex > *dataPtr)
virtual void putColumnSliceCellsdoubleV(const RefRows &rownrs, const Slicer &ns, const Array< double > *dataPtr)
virtual void putArrayColumnIntV(const Array< Int > *dataPtr)
virtual void putArrayV(rownr_t rownr, const ArrayBase &dataPtr)
Put the array value into the given row.
virtual void putArrayColumnuIntV(const Array< uInt > *dataPtr)
virtual void getComplexV(uInt rownr, Complex *dataPtr)
virtual IPosition tileShape(uInt rownr)
virtual void getDComplex(rownr_t rownr, DComplex *dataPtr)
virtual void setShapeTiled(uInt rownr, const IPosition &shape, const IPosition &tileShape)
virtual void putArrayIntV(uInt rownr, const Array< Int > *dataPtr)
virtual void putDComplexV(uInt rownr, const DComplex *dataPtr)
virtual void getArrayV(rownr_t rownr, ArrayBase &dataPtr)
Get the array value in the given row.
virtual void putColumnSlicefloatV(const Slicer &ns, const Array< float > *dataPtr)
virtual void getScalarColumnShortV(Vector< Short > *dataPtr)
virtual void getArrayStringV(uInt rownr, Array< String > *dataPtr)
virtual void getdoubleV(uInt rownr, double *dataPtr)
virtual void getScalarColumnCellsuCharV(const RefRows &rownrs, Vector< uChar > *dataPtr)
virtual void getColumnSliceuCharV(const Slicer &ns, Array< uChar > *dataPtr)
virtual void getColumnSliceDComplexV(const Slicer &ns, Array< DComplex > *dataPtr)
virtual void getfloatV(uInt rownr, float *dataPtr)
virtual void getSliceInt64V(uInt rownr, const Slicer &ns, Array< Int64 > *dataPtr)
virtual void putColumnSliceuShortV(const Slicer &ns, const Array< uShort > *dataPtr)
virtual void getuShort(rownr_t rownr, uShort *dataPtr)
virtual void getSliceStringV(uInt rownr, const Slicer &ns, Array< String > *dataPtr)
virtual void getArrayComplexV(uInt rownr, Array< Complex > *dataPtr)
virtual void putArrayColumnCellsDComplexV(const RefRows &rownrs, const Array< DComplex > *dataPtr)
virtual void getArrayColumnDComplexV(Array< DComplex > *dataPtr)
virtual void putScalarColumnCellsdoubleV(const RefRows &rownrs, const Vector< double > *dataPtr)
virtual void getColumnSliceShortV(const Slicer &ns, Array< Short > *dataPtr)
virtual void putuShort(rownr_t rownr, const uShort *dataPtr)
virtual void putColumnSliceCellsShortV(const RefRows &rownrs, const Slicer &ns, const Array< Short > *dataPtr)
virtual void getScalarColumnCellsfloatV(const RefRows &rownrs, Vector< float > *dataPtr)
virtual void putuShortV(uInt rownr, const uShort *dataPtr)
virtual void getArrayColumnCellsShortV(const RefRows &rownrs, Array< Short > *dataPtr)
virtual void getuIntV(uInt rownr, uInt *dataPtr)
virtual void putScalarColumnCellsV(const RefRows &rownrs, const ArrayBase &dataPtr)
Put some scalar values in the column.
virtual void getArrayColumnCellsDComplexV(const RefRows &rownrs, Array< DComplex > *dataPtr)
virtual void getArrayColumnCellsuIntV(const RefRows &rownrs, Array< uInt > *dataPtr)
virtual void getScalarColumnCellsShortV(const RefRows &rownrs, Vector< Short > *dataPtr)
virtual void putColumnSliceInt64V(const Slicer &ns, const Array< Int64 > *dataPtr)
virtual void getArrayColumnfloatV(Array< float > *dataPtr)
virtual void putScalarColumnShortV(const Vector< Short > *dataPtr)
virtual void getComplex(rownr_t rownr, Complex *dataPtr)
virtual void putArrayColumndoubleV(const Array< double > *dataPtr)
virtual void getArrayColumnuCharV(Array< uChar > *dataPtr)
virtual void getColumnSliceCellsBoolV(const RefRows &rownrs, const Slicer &ns, Array< Bool > *dataPtr)
Get the array values in some cells of the column.
virtual void putBool(rownr_t rownr, const Bool *dataPtr)
Put the scalar value in the given row.
virtual void getArrayColumnStringV(Array< String > *dataPtr)
virtual void putColumnSliceDComplexV(const Slicer &ns, const Array< DComplex > *dataPtr)
virtual void putColumnSliceShortV(const Slicer &ns, const Array< Short > *dataPtr)
virtual void putScalarColumnCellsComplexV(const RefRows &rownrs, const Vector< Complex > *dataPtr)
virtual void putScalarColumnfloatV(const Vector< float > *dataPtr)
virtual void putIntV(uInt rownr, const Int *dataPtr)
virtual void putColumnSliceIntV(const Slicer &ns, const Array< Int > *dataPtr)
virtual void putArrayComplexV(uInt rownr, const Array< Complex > *dataPtr)
virtual void getArrayuCharV(uInt rownr, Array< uChar > *dataPtr)
virtual void putArrayuIntV(uInt rownr, const Array< uInt > *dataPtr)
virtual void getArrayColumnCellsIntV(const RefRows &rownrs, Array< Int > *dataPtr)
virtual void putScalarColumnuShortV(const Vector< uShort > *dataPtr)
virtual void putColumnSliceuIntV(const Slicer &ns, const Array< uInt > *dataPtr)
virtual void getColumnSlicefloatV(const Slicer &ns, Array< float > *dataPtr)
virtual void putScalarColumnIntV(const Vector< Int > *dataPtr)
virtual void getShortV(uInt rownr, Short *dataPtr)
virtual void getArrayColumnCellsComplexV(const RefRows &rownrs, Array< Complex > *dataPtr)
virtual void getColumnSliceCellsdoubleV(const RefRows &rownrs, const Slicer &ns, Array< double > *dataPtr)
virtual void getScalarColumnuIntV(Vector< uInt > *dataPtr)
virtual void getScalarColumnuShortV(Vector< uShort > *dataPtr)
virtual void getArrayShortV(uInt rownr, Array< Short > *dataPtr)
virtual void putScalarColumnCellsIntV(const RefRows &rownrs, const Vector< Int > *dataPtr)
virtual void putScalarColumnDComplexV(const Vector< DComplex > *dataPtr)
virtual void getColumnSliceCellsuIntV(const RefRows &rownrs, const Slicer &ns, Array< uInt > *dataPtr)
virtual void getArrayuShortV(uInt rownr, Array< uShort > *dataPtr)
virtual void putScalarColumnCellsShortV(const RefRows &rownrs, const Vector< Short > *dataPtr)
virtual void putArrayColumnCellsInt64V(const RefRows &rownrs, const Array< Int64 > *dataPtr)
virtual void getColumnSliceCellsuCharV(const RefRows &rownrs, const Slicer &ns, Array< uChar > *dataPtr)
virtual void getShort(rownr_t rownr, Short *dataPtr)
virtual void getArrayColumnBoolV(Array< Bool > *dataPtr)
Get the array values in the entire column.
virtual void getScalarColumnCellsInt64V(const RefRows &rownrs, Vector< Int64 > *dataPtr)
virtual void putdouble(rownr_t rownr, const double *dataPtr)
virtual void getdouble(rownr_t rownr, double *dataPtr)
virtual void getArrayColumndoubleV(Array< double > *dataPtr)
virtual void putScalarColumndoubleV(const Vector< double > *dataPtr)
String: the storage and methods of handling collections of characters.
Definition: String.h:225
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
int Int
Definition: aipstype.h:50
bool Bool
Define the standard types used by Casacore.
Definition: aipstype.h:42
uInt64 rownr_t
Define the type of a row number in a table.
Definition: aipsxtype.h:46