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 
37 namespace 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 {
77 public:
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 
288 private:
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 
299 protected:
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);
344  virtual void getScalarColumnComplexV (Vector<Complex>* 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);
495  virtual void getArrayColumnDComplexV (Array<DComplex>* 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)
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)
StManColumn & operator=(const StManColumn &)
The object cannot be assigned to.
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