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/DataManager.h>
35 
36 namespace casacore { //# NAMESPACE CASACORE - BEGIN
37 
38 //# Forward Declarations
39 template<class T> class Vector;
40 
41 
42 // <summary>
43 // Base table column storage manager class
44 // </summary>
45 
46 // <use visibility=local>
47 
48 // <reviewed reviewer="Gareth Hunt" date="94Nov17" tests="">
49 // </reviewed>
50 
51 // <prerequisite>
52 //# Classes you should understand before using this one.
53 // <li> DataManagerColumn
54 // </prerequisite>
55 
56 // <etymology>
57 // StManColumn handles a column for a storage manager.
58 // </etymology>
59 
60 // <synopsis>
61 // StManColumn is the abstract base class to handle a column in all
62 // kind of storage managers. It is derived from DataManagerColumn
63 // and implements several virtual functions for derived storage
64 // manager column classes (like StManColumnAipsIO).
65 //
66 // All get and put functions (except for single scalars) in the abstract
67 // base class DataManagerColumn have a generic void* data argument.
68 // This is done to allow arbitrary typed arguments. This can be done
69 // because the data type of the derived class always matches the
70 // type of the data argument.
71 // However, at one time the void* has to be casted to the exact type.
72 // Storage managers only support the standard data types; therefore
73 // it is possible to do the cast in a base class. This concentrates
74 // the burden in one class and allows the derived classes to work
75 // with correctly typed arguments.
76 // The price is an extra virtual function call, but that is not a
77 // problem for (expensive) operations on arrays.
78 // It is not done for single scalars, because that price may be too high.
79 //
80 // See StManColumnAipsIO for the get/put functions required in a storage
81 // manager column class handling scalars.
82 // See StManColumnArrayAipsIO for the get/put functions required in a
83 // storage manager column class handling arrays. This class also
84 // contains the shape functions for direct arrays, while
85 // StManColumnIndArrayAipsIO contains the shape functions for indirec
86 // arrays.
87 //
88 // StManColumn also contains the data type of the column (which it
89 // gets from the derived classes at construction time) and implements
90 // the function dataType on behalf of its derived classes.
91 // </synopsis>
92 
93 // <motivation>
94 // Making life easier for the derived classes.
95 // </motivation>
96 
97 // <todo asof="$DATE:$">
98 //# A List of bugs, limitations, extensions or planned refinements.
99 // </todo>
100 
101 
103 {
104 public:
105 
106  // Default constructor.
107  StManColumn (int dataType);
108 
109  ~StManColumn();
110 
111  // Test if the given data type is supported by storage managers.
112  // It is used by the function Table::isNativeDataType.
113  static Bool isNativeDataType (int dtype);
114 
115  // Return the data type of the column.
116  int dataType() const;
117 
118  // By default the storage manager can handle access to a scalar column.
119  Bool canAccessScalarColumn (Bool& reask) const;
120 
121  // All storage managers can handle access to scalar column cells, because
122  // this class contains a default implementation of getScalarColumnCellsV.
123  Bool canAccessScalarColumnCells (Bool& reask) const;
124 
125  // All storage managers can handle access to array column cells, because
126  // this class contains a default implementation of getArrayColumnCellsV.
127  Bool canAccessArrayColumnCells (Bool& reask) const;
128 
129  // Get all scalar values in the column.
130  // The argument dataPtr is in fact a Vector<T>*, but a void*
131  // is needed to be generic.
132  // The vector pointed to by dataPtr has to have the correct length
133  // (which is guaranteed by the ScalarColumn getColumn function).
134  // The default implementation calls the appropriate getScalarColumnXXV.
135  void getScalarColumnV (void* dataPtr);
136 
137  // Put all scalar values in the column.
138  // The argument dataPtr is in fact a const Vector<T>*, but a const void*
139  // is needed to be generic.
140  // The vector pointed to by dataPtr has to have the correct length
141  // (which is guaranteed by the ScalarColumn putColumn function).
142  // The default implementation calls the appropriate putScalarColumnXXV.
143  void putScalarColumnV (const void* dataPtr);
144 
145  // Get some scalar values in the column.
146  // The argument dataPtr is in fact a Vector<T>*, but a void*
147  // is needed to be generic.
148  // The vector pointed to by dataPtr has to have the correct length
149  // (which is guaranteed by the ScalarColumn getColumn function).
150  // The default implementation calls the appropriate getScalarColumnCellsXXV.
151  void getScalarColumnCellsV (const RefRows& rownrs,
152  void* dataPtr);
153 
154  // Put some scalar values in the column.
155  // The argument dataPtr is in fact a const Vector<T>*, but a const void*
156  // is needed to be generic.
157  // The vector pointed to by dataPtr has to have the correct length
158  // (which is guaranteed by the ScalarColumn getColumn function).
159  // The default implementation calls the appropriate putScalarColumnCellsXXV.
160  void putScalarColumnCellsV (const RefRows& rownrs,
161  const void* dataPtr);
162 
163  // Get scalars from the given row on with a maximum of nrmax values.
164  // It returns the actual number of values got.
165  // This can be used to get an entire column of scalars or to get
166  // a part of a column (for a cache for example).
167  // The argument dataPtr is in fact a T*, but a void*
168  // is needed to be generic.
169  // The default implementation calls the appropriate getBlockXXV function.
170  uInt getBlockV (uInt rownr, uInt nrmax, void* dataPtr);
171 
172  // Put nrmax scalars from the given row on.
173  // It returns the actual number of values put.
174  // This can be used to put an entire column of scalars or to put
175  // a part of a column (for a cache for example).
176  // The argument dataPtr is in fact a const T*, but a const void*
177  // is needed to be generic.
178  // The default implementation calls the appropriate putBlockXXV function.
179  void putBlockV (uInt rownr, uInt nrmax, const void* dataPtr);
180 
181  // Get the array value in the given row.
182  // The argument dataPtr is in fact an Array<T>*, but a void*
183  // is needed to be generic.
184  // The array pointed to by dataPtr has to have the correct shape
185  // (which is guaranteed by the ArrayColumn get function).
186  // The default implementation calls the appropriate getArrayXXV.
187  void getArrayV (uInt rownr, void* dataPtr);
188 
189  // Put the array value into the given row.
190  // The argument dataPtr is in fact a const Array<T>*, but a const void*
191  // is needed to be generic.
192  // The array pointed to by dataPtr has to have the correct shape
193  // (which is guaranteed by the ArrayColumn put function).
194  // The default implementation calls the appropriate putArrayXXV.
195  void putArrayV (uInt rownr, const void* dataPtr);
196 
197  // Get all array values in the column.
198  // The argument dataPtr is in fact an Array<T>*, but a void*
199  // is needed to be generic.
200  // The vector pointed to by dataPtr has to have the correct length
201  // (which is guaranteed by the ArrayColumn getColumn function).
202  // The default implementation calls the appropriate getArrayColumnXXV.
203  void getArrayColumnV (void* dataPtr);
204 
205  // Put all array values in the column.
206  // The argument dataPtr is in fact a const Array<T>*, but a const void*
207  // is needed to be generic.
208  // The vector pointed to by dataPtr has to have the correct length
209  // (which is guaranteed by the ArrayColumn putColumn function).
210  // The default implementation calls the appropriate putArrayColumnXXV.
211  void putArrayColumnV (const void* dataPtr);
212 
213  // Get some array values in the column.
214  // The argument dataPtr is in fact an Array<T>*, but a void*
215  // is needed to be generic.
216  // The vector pointed to by dataPtr has to have the correct length
217  // (which is guaranteed by the ArrayColumn getColumn function).
218  // The default implementation calls the appropriate getArrayColumnCellsXXV.
219  void getArrayColumnCellsV (const RefRows& rownrs, void* dataPtr);
220 
221  // Put some array values in the column.
222  // The argument dataPtr is in fact an const Array<T>*, but a const void*
223  // is needed to be generic.
224  // The vector pointed to by dataPtr has to have the correct length
225  // (which is guaranteed by the ArrayColumn getColumn function).
226  // The default implementation calls the appropriate putArrayColumnCellsXXV.
227  void putArrayColumnCellsV (const RefRows& rownrs, const void* dataPtr);
228 
229  // Get a section of the array in the given row.
230  // The argument dataPtr is in fact an Array<T>*, but a void*
231  // is needed to be generic.
232  // The array pointed to by dataPtr has to have the correct shape
233  // (which is guaranteed by the ArrayColumn getSlice function).
234  // The default implementation calls the appropriate getSliceXXV.
235  void getSliceV (uInt rownr, const Slicer& slicer, void* dataPtr);
236 
237  // Put into a section of the array in the given row.
238  // The argument dataPtr is in fact a const Array<T>*, but a const void*
239  // is needed to be generic.
240  // The array pointed to by dataPtr has to have the correct shape
241  // (which is guaranteed by the ArrayColumn putSlice function).
242  // The default implementation calls the appropriate putSliceXXV.
243  void putSliceV (uInt rownr, const Slicer& slicer, const void* dataPtr);
244 
245  // Get a section of all arrays in the column.
246  // The argument dataPtr is in fact an Array<T>*, but a void*
247  // is needed to be generic.
248  // The array pointed to by dataPtr has to have the correct shape
249  // (which is guaranteed by the ArrayColumn getColumn function).
250  // The default implementation calls the appropriate getColumnSliceXXV.
251  void getColumnSliceV (const Slicer& slicer, void* dataPtr);
252 
253  // Put into a section of all arrays in the column.
254  // The argument dataPtr is in fact a const Array<T>*, but a const void*
255  // is needed to be generic.
256  // The array pointed to by dataPtr has to have the correct shape
257  // (which is guaranteed by the ArrayColumn putColumn function).
258  // The default implementation calls the appropriate putColumnSliceXXV.
259  void putColumnSliceV (const Slicer& slicer, const void* dataPtr);
260 
261  // Get a section of some arrays in the column.
262  // The argument dataPtr is in fact an Array<T>*, but a void*
263  // is needed to be generic.
264  // The array pointed to by dataPtr has to have the correct shape
265  // (which is guaranteed by the ArrayColumn getColumn function).
266  // The default implementation calls the appropriate getColumnSliceCellsXXV.
267  virtual void getColumnSliceCellsV (const RefRows& rownrs,
268  const Slicer& slicer, void* dataPtr);
269 
270  // Put into a section of some arrays in the column.
271  // The argument dataPtr is in fact a const Array<T>*, but a const void*
272  // is needed to be generic.
273  // The array pointed to by dataPtr has to have the correct shape
274  // (which is guaranteed by the ArrayColumn putColumn function).
275  // The default implementation calls the appropriate putColumnSliceCellsXXV.
276  virtual void putColumnSliceCellsV (const RefRows& rownrs,
277  const Slicer& slicer,
278  const void* dataPtr);
279 
280 
281 private:
282  // The object cannot be copied.
283  StManColumn (const StManColumn&);
284 
285  // The object cannot be assigned to.
287 
288  // Throw an "invalid operation" exception for the default
289  // implementation of getArray.
290  void throwGetArray() const;
291 
292  // Throw an "invalid operation" exception for the default
293  // implementation of putArray.
294  void throwPutArray() const;
295 
296 
297 protected:
298  // Get the scalar values in the entire column.
299  // The buffer pointed to by dataPtr has to have the correct length.
300  // (which is guaranteed by the ScalarColumn getColumn function).
301  // The default implementation uses the corresponding getBlockXXXV.
302  // <group>
303  virtual void getScalarColumnBoolV (Vector<Bool>* dataPtr);
304  virtual void getScalarColumnuCharV (Vector<uChar>* dataPtr);
305  virtual void getScalarColumnShortV (Vector<Short>* dataPtr);
306  virtual void getScalarColumnuShortV (Vector<uShort>* dataPtr);
307  virtual void getScalarColumnIntV (Vector<Int>* dataPtr);
308  virtual void getScalarColumnuIntV (Vector<uInt>* dataPtr);
309  virtual void getScalarColumnfloatV (Vector<float>* dataPtr);
310  virtual void getScalarColumndoubleV (Vector<double>* dataPtr);
311  virtual void getScalarColumnComplexV (Vector<Complex>* dataPtr);
312  virtual void getScalarColumnDComplexV (Vector<DComplex>* dataPtr);
313  virtual void getScalarColumnStringV (Vector<String>* dataPtr);
314  // </group>
315 
316  // Put the scalar values into the entire column.
317  // The buffer pointed to by dataPtr has to have the correct length.
318  // (which is guaranteed by the ScalarColumn putColumn function).
319  // The default implementation uses the corresponding putBlockXXXV.
320  // <group>
321  virtual void putScalarColumnBoolV (const Vector<Bool>* dataPtr);
322  virtual void putScalarColumnuCharV (const Vector<uChar>* dataPtr);
323  virtual void putScalarColumnShortV (const Vector<Short>* dataPtr);
324  virtual void putScalarColumnuShortV (const Vector<uShort>* dataPtr);
325  virtual void putScalarColumnIntV (const Vector<Int>* dataPtr);
326  virtual void putScalarColumnuIntV (const Vector<uInt>* dataPtr);
327  virtual void putScalarColumnfloatV (const Vector<float>* dataPtr);
328  virtual void putScalarColumndoubleV (const Vector<double>* dataPtr);
329  virtual void putScalarColumnComplexV (const Vector<Complex>* dataPtr);
330  virtual void putScalarColumnDComplexV (const Vector<DComplex>* dataPtr);
331  virtual void putScalarColumnStringV (const Vector<String>* dataPtr);
332  // </group>
333 
334  // Get the scalar values in some cells of the column.
335  // The buffer pointed to by dataPtr has to have the correct length.
336  // (which is guaranteed by the ScalarColumn getColumnCells function).
337  // The default implementation loops through all rows.
338  // <group>
339  virtual void getScalarColumnCellsBoolV (const RefRows& rownrs,
340  Vector<Bool>* dataPtr);
341  virtual void getScalarColumnCellsuCharV (const RefRows& rownrs,
342  Vector<uChar>* dataPtr);
343  virtual void getScalarColumnCellsShortV (const RefRows& rownrs,
344  Vector<Short>* dataPtr);
345  virtual void getScalarColumnCellsuShortV (const RefRows& rownrs,
346  Vector<uShort>* dataPtr);
347  virtual void getScalarColumnCellsIntV (const RefRows& rownrs,
348  Vector<Int>* dataPtr);
349  virtual void getScalarColumnCellsuIntV (const RefRows& rownrs,
350  Vector<uInt>* dataPtr);
351  virtual void getScalarColumnCellsfloatV (const RefRows& rownrs,
352  Vector<float>* dataPtr);
353  virtual void getScalarColumnCellsdoubleV (const RefRows& rownrs,
354  Vector<double>* dataPtr);
355  virtual void getScalarColumnCellsComplexV (const RefRows& rownrs,
356  Vector<Complex>* dataPtr);
357  virtual void getScalarColumnCellsDComplexV (const RefRows& rownrs,
358  Vector<DComplex>* dataPtr);
359  virtual void getScalarColumnCellsStringV (const RefRows& rownrs,
360  Vector<String>* dataPtr);
361  // </group>
362 
363  // Put the scalar values into some cells of the column.
364  // The buffer pointed to by dataPtr has to have the correct length.
365  // (which is guaranteed by the ScalarColumn putColumnCells function).
366  // The default implementation loops through all rows.
367  // <group>
368  virtual void putScalarColumnCellsBoolV (const RefRows& rownrs,
369  const Vector<Bool>* dataPtr);
370  virtual void putScalarColumnCellsuCharV (const RefRows& rownrs,
371  const Vector<uChar>* dataPtr);
372  virtual void putScalarColumnCellsShortV (const RefRows& rownrs,
373  const Vector<Short>* dataPtr);
374  virtual void putScalarColumnCellsuShortV (const RefRows& rownrs,
375  const Vector<uShort>* dataPtr);
376  virtual void putScalarColumnCellsIntV (const RefRows& rownrs,
377  const Vector<Int>* dataPtr);
378  virtual void putScalarColumnCellsuIntV (const RefRows& rownrs,
379  const Vector<uInt>* dataPtr);
380  virtual void putScalarColumnCellsfloatV (const RefRows& rownrs,
381  const Vector<float>* dataPtr);
382  virtual void putScalarColumnCellsdoubleV (const RefRows& rownrs,
383  const Vector<double>* dataPtr);
384  virtual void putScalarColumnCellsComplexV (const RefRows& rownrs,
385  const Vector<Complex>* dataPtr);
386  virtual void putScalarColumnCellsDComplexV (const RefRows& rownrs,
387  const Vector<DComplex>* dataPtr);
388  virtual void putScalarColumnCellsStringV (const RefRows& rownrs,
389  const Vector<String>* dataPtr);
390  // </group>
391 
392  // Get scalars from the given row on with a maximum of nrmax values.
393  // This can be used to get an entire column of scalars or to get
394  // a part of a column (for a cache for example).
395  // The buffer pointed to by dataPtr has to have the length nrmax.
396  // (which is guaranteed by the ScalarColumn get function).
397  // The default implementation gets one value.
398  // <group>
399  virtual uInt getBlockBoolV (uInt rownr, uInt nrmax,
400  Bool* dataPtr);
401  virtual uInt getBlockuCharV (uInt rownr, uInt nrmax,
402  uChar* dataPtr);
403  virtual uInt getBlockShortV (uInt rownr, uInt nrmax,
404  Short* dataPtr);
405  virtual uInt getBlockuShortV (uInt rownr, uInt nrmax,
406  uShort* dataPtr);
407  virtual uInt getBlockIntV (uInt rownr, uInt nrmax,
408  Int* dataPtr);
409  virtual uInt getBlockuIntV (uInt rownr, uInt nrmax,
410  uInt* dataPtr);
411  virtual uInt getBlockfloatV (uInt rownr, uInt nrmax,
412  float* dataPtr);
413  virtual uInt getBlockdoubleV (uInt rownr, uInt nrmax,
414  double* dataPtr);
415  virtual uInt getBlockComplexV (uInt rownr, uInt nrmax,
416  Complex* dataPtr);
417  virtual uInt getBlockDComplexV (uInt rownr, uInt nrmax,
418  DComplex* dataPtr);
419  virtual uInt getBlockStringV (uInt rownr, uInt nrmax,
420  String* dataPtr);
421  // </group>
422 
423  // Put nrmax scalars from the given row on.
424  // This can be used to put an entire column of scalars or to put
425  // a part of a column (for a cache for example).
426  // The buffer pointed to by dataPtr has to have the length nrmax.
427  // The default implementation puts one value at the time.
428  // <group>
429  virtual void putBlockBoolV (uInt rownr, uInt nrmax,
430  const Bool* dataPtr);
431  virtual void putBlockuCharV (uInt rownr, uInt nrmax,
432  const uChar* dataPtr);
433  virtual void putBlockShortV (uInt rownr, uInt nrmax,
434  const Short* dataPtr);
435  virtual void putBlockuShortV (uInt rownr, uInt nrmax,
436  const uShort* dataPtr);
437  virtual void putBlockIntV (uInt rownr, uInt nrmax,
438  const Int* dataPtr);
439  virtual void putBlockuIntV (uInt rownr, uInt nrmax,
440  const uInt* dataPtr);
441  virtual void putBlockfloatV (uInt rownr, uInt nrmax,
442  const float* dataPtr);
443  virtual void putBlockdoubleV (uInt rownr, uInt nrmax,
444  const double* dataPtr);
445  virtual void putBlockComplexV (uInt rownr, uInt nrmax,
446  const Complex* dataPtr);
447  virtual void putBlockDComplexV (uInt rownr, uInt nrmax,
448  const DComplex* dataPtr);
449  virtual void putBlockStringV (uInt rownr, uInt nrmax,
450  const String* dataPtr);
451  // </group>
452 
453  // Get the array value in the given row.
454  // The array pointed to by dataPtr has to have the correct length
455  // (which is guaranteed by the ArrayColumn get function).
456  // The default implementation loops through all rows.
457  // <group>
458  virtual void getArrayBoolV (uInt rownr, Array<Bool>* dataPtr);
459  virtual void getArrayuCharV (uInt rownr, Array<uChar>* dataPtr);
460  virtual void getArrayShortV (uInt rownr, Array<Short>* dataPtr);
461  virtual void getArrayuShortV (uInt rownr, Array<uShort>* dataPtr);
462  virtual void getArrayIntV (uInt rownr, Array<Int>* dataPtr);
463  virtual void getArrayuIntV (uInt rownr, Array<uInt>* dataPtr);
464  virtual void getArrayfloatV (uInt rownr, Array<float>* dataPtr);
465  virtual void getArraydoubleV (uInt rownr, Array<double>* dataPtr);
466  virtual void getArrayComplexV (uInt rownr, Array<Complex>* dataPtr);
467  virtual void getArrayDComplexV (uInt rownr, Array<DComplex>* dataPtr);
468  virtual void getArrayStringV (uInt rownr, Array<String>* dataPtr);
469  // </group>
470 
471  // Put the array value into the given row.
472  // The buffer pointed to by dataPtr has to have the correct length
473  // (which is guaranteed by the ArrayColumn put function).
474  // The default implementation loops through all rows.
475  // <group>
476  virtual void putArrayBoolV (uInt rownr,
477  const Array<Bool>* dataPtr);
478  virtual void putArrayuCharV (uInt rownr,
479  const Array<uChar>* dataPtr);
480  virtual void putArrayShortV (uInt rownr,
481  const Array<Short>* dataPtr);
482  virtual void putArrayuShortV (uInt rownr,
483  const Array<uShort>* dataPtr);
484  virtual void putArrayIntV (uInt rownr,
485  const Array<Int>* dataPtr);
486  virtual void putArrayuIntV (uInt rownr,
487  const Array<uInt>* dataPtr);
488  virtual void putArrayfloatV (uInt rownr,
489  const Array<float>* dataPtr);
490  virtual void putArraydoubleV (uInt rownr,
491  const Array<double>* dataPtr);
492  virtual void putArrayComplexV (uInt rownr,
493  const Array<Complex>* dataPtr);
494  virtual void putArrayDComplexV (uInt rownr,
495  const Array<DComplex>* dataPtr);
496  virtual void putArrayStringV (uInt rownr,
497  const Array<String>* dataPtr);
498  // </group>
499 
500  // Get the array values in the entire column.
501  // The buffer pointed to by dataPtr has to have the correct length.
502  // (which is guaranteed by the ArrayColumn getColumn function).
503  // The default implementation uses the corresponding getBlockXXXV.
504  // <group>
505  virtual void getArrayColumnBoolV (Array<Bool>* dataPtr);
506  virtual void getArrayColumnuCharV (Array<uChar>* dataPtr);
507  virtual void getArrayColumnShortV (Array<Short>* dataPtr);
508  virtual void getArrayColumnuShortV (Array<uShort>* dataPtr);
509  virtual void getArrayColumnIntV (Array<Int>* dataPtr);
510  virtual void getArrayColumnuIntV (Array<uInt>* dataPtr);
511  virtual void getArrayColumnfloatV (Array<float>* dataPtr);
512  virtual void getArrayColumndoubleV (Array<double>* dataPtr);
513  virtual void getArrayColumnComplexV (Array<Complex>* dataPtr);
514  virtual void getArrayColumnDComplexV (Array<DComplex>* dataPtr);
515  virtual void getArrayColumnStringV (Array<String>* dataPtr);
516  // </group>
517 
518  // Put the array values into the entire column.
519  // The buffer pointed to by dataPtr has to have the correct length.
520  // (which is guaranteed by the ArrayColumn putColumn function).
521  // The default implementation uses the corresponding putBlockXXXV.
522  // <group>
523  virtual void putArrayColumnBoolV (const Array<Bool>* dataPtr);
524  virtual void putArrayColumnuCharV (const Array<uChar>* dataPtr);
525  virtual void putArrayColumnShortV (const Array<Short>* dataPtr);
526  virtual void putArrayColumnuShortV (const Array<uShort>* dataPtr);
527  virtual void putArrayColumnIntV (const Array<Int>* dataPtr);
528  virtual void putArrayColumnuIntV (const Array<uInt>* dataPtr);
529  virtual void putArrayColumnfloatV (const Array<float>* dataPtr);
530  virtual void putArrayColumndoubleV (const Array<double>* dataPtr);
531  virtual void putArrayColumnComplexV (const Array<Complex>* dataPtr);
532  virtual void putArrayColumnDComplexV (const Array<DComplex>* dataPtr);
533  virtual void putArrayColumnStringV (const Array<String>* dataPtr);
534  // </group>
535 
536  // Get the array values in some cells of the column.
537  // The buffer pointed to by dataPtr has to have the correct length.
538  // (which is guaranteed by the ArrayColumn getColumnCells function).
539  // The default implementation throws an "invalid operation exception".
540  // <group>
541  virtual void getArrayColumnCellsBoolV (const RefRows& rownrs,
542  Array<Bool>* dataPtr);
543  virtual void getArrayColumnCellsuCharV (const RefRows& rownrs,
544  Array<uChar>* dataPtr);
545  virtual void getArrayColumnCellsShortV (const RefRows& rownrs,
546  Array<Short>* dataPtr);
547  virtual void getArrayColumnCellsuShortV (const RefRows& rownrs,
548  Array<uShort>* dataPtr);
549  virtual void getArrayColumnCellsIntV (const RefRows& rownrs,
550  Array<Int>* dataPtr);
551  virtual void getArrayColumnCellsuIntV (const RefRows& rownrs,
552  Array<uInt>* dataPtr);
553  virtual void getArrayColumnCellsfloatV (const RefRows& rownrs,
554  Array<float>* dataPtr);
555  virtual void getArrayColumnCellsdoubleV (const RefRows& rownrs,
556  Array<double>* dataPtr);
557  virtual void getArrayColumnCellsComplexV (const RefRows& rownrs,
558  Array<Complex>* dataPtr);
559  virtual void getArrayColumnCellsDComplexV (const RefRows& rownrs,
560  Array<DComplex>* dataPtr);
561  virtual void getArrayColumnCellsStringV (const RefRows& rownrs,
562  Array<String>* dataPtr);
563  // </group>
564 
565  // Put the array values into some cells of the column.
566  // The buffer pointed to by dataPtr has to have the correct length.
567  // (which is guaranteed by the ArrayColumn putColumnCells function).
568  // The default implementation throws an "invalid operation exception".
569  // <group>
570  virtual void putArrayColumnCellsBoolV (const RefRows& rownrs,
571  const Array<Bool>* dataPtr);
572  virtual void putArrayColumnCellsuCharV (const RefRows& rownrs,
573  const Array<uChar>* dataPtr);
574  virtual void putArrayColumnCellsShortV (const RefRows& rownrs,
575  const Array<Short>* dataPtr);
576  virtual void putArrayColumnCellsuShortV (const RefRows& rownrs,
577  const Array<uShort>* dataPtr);
578  virtual void putArrayColumnCellsIntV (const RefRows& rownrs,
579  const Array<Int>* dataPtr);
580  virtual void putArrayColumnCellsuIntV (const RefRows& rownrs,
581  const Array<uInt>* dataPtr);
582  virtual void putArrayColumnCellsfloatV (const RefRows& rownrs,
583  const Array<float>* dataPtr);
584  virtual void putArrayColumnCellsdoubleV (const RefRows& rownrs,
585  const Array<double>* dataPtr);
586  virtual void putArrayColumnCellsComplexV (const RefRows& rownrs,
587  const Array<Complex>* dataPtr);
588  virtual void putArrayColumnCellsDComplexV (const RefRows& rownrs,
589  const Array<DComplex>* dataPtr);
590  virtual void putArrayColumnCellsStringV (const RefRows& rownrs,
591  const Array<String>* dataPtr);
592  // </group>
593 
594  // Get the array value in the given row.
595  // The array pointed to by dataPtr has to have the correct length
596  // (which is guaranteed by the ArrayColumn getSlice function).
597  // The default implementation throws an "invalid operation exception".
598  // <group>
599  virtual void getSliceBoolV (uInt rownr, const Slicer& ns,
600  Array<Bool>* dataPtr);
601  virtual void getSliceuCharV (uInt rownr, const Slicer& ns,
602  Array<uChar>* dataPtr);
603  virtual void getSliceShortV (uInt rownr, const Slicer& ns,
604  Array<Short>* dataPtr);
605  virtual void getSliceuShortV (uInt rownr, const Slicer& ns,
606  Array<uShort>* dataPtr);
607  virtual void getSliceIntV (uInt rownr, const Slicer& ns,
608  Array<Int>* dataPtr);
609  virtual void getSliceuIntV (uInt rownr, const Slicer& ns,
610  Array<uInt>* dataPtr);
611  virtual void getSlicefloatV (uInt rownr, const Slicer& ns,
612  Array<float>* dataPtr);
613  virtual void getSlicedoubleV (uInt rownr, const Slicer& ns,
614  Array<double>* dataPtr);
615  virtual void getSliceComplexV (uInt rownr, const Slicer& ns,
616  Array<Complex>* dataPtr);
617  virtual void getSliceDComplexV (uInt rownr, const Slicer& ns,
618  Array<DComplex>* dataPtr);
619  virtual void getSliceStringV (uInt rownr, const Slicer& ns,
620  Array<String>* dataPtr);
621  // </group>
622 
623  // Put the array value into the given row.
624  // The buffer pointed to by dataPtr has to have the correct length
625  // (which is guaranteed by the ArrayColumn putSlice function).
626  // The default implementation throws an "invalid operation exception".
627  // <group>
628  virtual void putSliceBoolV (uInt rownr, const Slicer& ns,
629  const Array<Bool>* dataPtr);
630  virtual void putSliceuCharV (uInt rownr, const Slicer& ns,
631  const Array<uChar>* dataPtr);
632  virtual void putSliceShortV (uInt rownr, const Slicer& ns,
633  const Array<Short>* dataPtr);
634  virtual void putSliceuShortV (uInt rownr, const Slicer& ns,
635  const Array<uShort>* dataPtr);
636  virtual void putSliceIntV (uInt rownr, const Slicer& ns,
637  const Array<Int>* dataPtr);
638  virtual void putSliceuIntV (uInt rownr, const Slicer& ns,
639  const Array<uInt>* dataPtr);
640  virtual void putSlicefloatV (uInt rownr, const Slicer& ns,
641  const Array<float>* dataPtr);
642  virtual void putSlicedoubleV (uInt rownr, const Slicer& ns,
643  const Array<double>* dataPtr);
644  virtual void putSliceComplexV (uInt rownr, const Slicer& ns,
645  const Array<Complex>* dataPtr);
646  virtual void putSliceDComplexV (uInt rownr, const Slicer& ns,
647  const Array<DComplex>* dataPtr);
648  virtual void putSliceStringV (uInt rownr, const Slicer& ns,
649  const Array<String>* dataPtr);
650  // </group>
651 
652  // Get the array values in the entire column.
653  // The buffer pointed to by dataPtr has to have the correct length.
654  // (which is guaranteed by the ArrayColumn getColumn function).
655  // The default implementation uses the corresponding getBlockXXXV.
656  // <group>
657  virtual void getColumnSliceBoolV (const Slicer& ns,
658  Array<Bool>* dataPtr);
659  virtual void getColumnSliceuCharV (const Slicer& ns,
660  Array<uChar>* dataPtr);
661  virtual void getColumnSliceShortV (const Slicer& ns,
662  Array<Short>* dataPtr);
663  virtual void getColumnSliceuShortV (const Slicer& ns,
664  Array<uShort>* dataPtr);
665  virtual void getColumnSliceIntV (const Slicer& ns,
666  Array<Int>* dataPtr);
667  virtual void getColumnSliceuIntV (const Slicer& ns,
668  Array<uInt>* dataPtr);
669  virtual void getColumnSlicefloatV (const Slicer& ns,
670  Array<float>* dataPtr);
671  virtual void getColumnSlicedoubleV (const Slicer& ns,
672  Array<double>* dataPtr);
673  virtual void getColumnSliceComplexV (const Slicer& ns,
674  Array<Complex>* dataPtr);
675  virtual void getColumnSliceDComplexV (const Slicer& ns,
676  Array<DComplex>* dataPtr);
677  virtual void getColumnSliceStringV (const Slicer& ns,
678  Array<String>* dataPtr);
679  // </group>
680 
681  // Put the array values into the entire column.
682  // The buffer pointed to by dataPtr has to have the correct length.
683  // (which is guaranteed by the ArrayColumn putColumn function).
684  // The default implementation uses the corresponding putBlockXXXV.
685  // <group>
686  virtual void putColumnSliceBoolV (const Slicer& ns,
687  const Array<Bool>* dataPtr);
688  virtual void putColumnSliceuCharV (const Slicer& ns,
689  const Array<uChar>* dataPtr);
690  virtual void putColumnSliceShortV (const Slicer& ns,
691  const Array<Short>* dataPtr);
692  virtual void putColumnSliceuShortV (const Slicer& ns,
693  const Array<uShort>* dataPtr);
694  virtual void putColumnSliceIntV (const Slicer& ns,
695  const Array<Int>* dataPtr);
696  virtual void putColumnSliceuIntV (const Slicer& ns,
697  const Array<uInt>* dataPtr);
698  virtual void putColumnSlicefloatV (const Slicer& ns,
699  const Array<float>* dataPtr);
700  virtual void putColumnSlicedoubleV (const Slicer& ns,
701  const Array<double>* dataPtr);
702  virtual void putColumnSliceComplexV (const Slicer& ns,
703  const Array<Complex>* dataPtr);
704  virtual void putColumnSliceDComplexV (const Slicer& ns,
705  const Array<DComplex>* dataPtr);
706  virtual void putColumnSliceStringV (const Slicer& ns,
707  const Array<String>* dataPtr);
708  // </group>
709 
710  // Get the array values in some cells of the column.
711  // The buffer pointed to by dataPtr has to have the correct length.
712  // (which is guaranteed by the ArrayColumn getColumnCells function).
713  // The default implementation throws an "invalid operation exception".
714  // <group>
715  virtual void getColumnSliceCellsBoolV (const RefRows& rownrs,
716  const Slicer& ns,
717  Array<Bool>* dataPtr);
718  virtual void getColumnSliceCellsuCharV (const RefRows& rownrs,
719  const Slicer& ns,
720  Array<uChar>* dataPtr);
721  virtual void getColumnSliceCellsShortV (const RefRows& rownrs,
722  const Slicer& ns,
723  Array<Short>* dataPtr);
724  virtual void getColumnSliceCellsuShortV (const RefRows& rownrs,
725  const Slicer& ns,
726  Array<uShort>* dataPtr);
727  virtual void getColumnSliceCellsIntV (const RefRows& rownrs,
728  const Slicer& ns,
729  Array<Int>* dataPtr);
730  virtual void getColumnSliceCellsuIntV (const RefRows& rownrs,
731  const Slicer& ns,
732  Array<uInt>* dataPtr);
733  virtual void getColumnSliceCellsfloatV (const RefRows& rownrs,
734  const Slicer& ns,
735  Array<float>* dataPtr);
736  virtual void getColumnSliceCellsdoubleV (const RefRows& rownrs,
737  const Slicer& ns,
738  Array<double>* dataPtr);
739  virtual void getColumnSliceCellsComplexV (const RefRows& rownrs,
740  const Slicer& ns,
741  Array<Complex>* dataPtr);
742  virtual void getColumnSliceCellsDComplexV (const RefRows& rownrs,
743  const Slicer& ns,
744  Array<DComplex>* dataPtr);
745  virtual void getColumnSliceCellsStringV (const RefRows& rownrs,
746  const Slicer& ns,
747  Array<String>* dataPtr);
748  // </group>
749 
750  // Put the array values into some cells of the column.
751  // The buffer pointed to by dataPtr has to have the correct length.
752  // (which is guaranteed by the ArrayColumn putColumnSlice function).
753  // The default implementation throws an "invalid operation exception".
754  // <group>
755  virtual void putColumnSliceCellsBoolV (const RefRows& rownrs,
756  const Slicer& ns,
757  const Array<Bool>* dataPtr);
758  virtual void putColumnSliceCellsuCharV (const RefRows& rownrs,
759  const Slicer& ns,
760  const Array<uChar>* dataPtr);
761  virtual void putColumnSliceCellsShortV (const RefRows& rownrs,
762  const Slicer& ns,
763  const Array<Short>* dataPtr);
764  virtual void putColumnSliceCellsuShortV (const RefRows& rownrs,
765  const Slicer& ns,
766  const Array<uShort>* dataPtr);
767  virtual void putColumnSliceCellsIntV (const RefRows& rownrs,
768  const Slicer& ns,
769  const Array<Int>* dataPtr);
770  virtual void putColumnSliceCellsuIntV (const RefRows& rownrs,
771  const Slicer& ns,
772  const Array<uInt>* 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 private:
792  // The data type of the column.
793  int dtype_p;
794 };
795 
796 
797 
798 
799 } //# NAMESPACE CASACORE - END
800 
801 #endif
virtual void putArrayColumnDComplexV(const Array< DComplex > *dataPtr)
virtual void putArrayColumnStringV(const Array< String > *dataPtr)
virtual void putArrayColumnCellsBoolV(const RefRows &rownrs, const Array< Bool > *dataPtr)
Put the array values into some cells of the column.
virtual void putColumnSliceCellsuShortV(const RefRows &rownrs, const Slicer &ns, const Array< uShort > *dataPtr)
virtual void getArrayColumnCellsuIntV(const RefRows &rownrs, Array< uInt > *dataPtr)
virtual void putArrayShortV(uInt rownr, const Array< Short > *dataPtr)
int Int
Definition: aipstype.h:47
virtual void getArrayColumnShortV(Array< Short > *dataPtr)
virtual void getColumnSliceCellsComplexV(const RefRows &rownrs, const Slicer &ns, Array< Complex > *dataPtr)
virtual void getColumnSliceCellsV(const RefRows &rownrs, const Slicer &slicer, void *dataPtr)
Get a section of some arrays in the column.
virtual void getArrayStringV(uInt rownr, Array< String > *dataPtr)
static Bool isNativeDataType(int dtype)
Test if the given data type is supported by storage managers.
virtual void putColumnSliceShortV(const Slicer &ns, const Array< Short > *dataPtr)
virtual void getArrayColumnCellsIntV(const RefRows &rownrs, Array< Int > *dataPtr)
virtual void getColumnSliceuShortV(const Slicer &ns, Array< uShort > *dataPtr)
virtual uInt getBlockStringV(uInt rownr, uInt nrmax, String *dataPtr)
virtual void putColumnSliceCellsuIntV(const RefRows &rownrs, const Slicer &ns, const Array< uInt > *dataPtr)
virtual void putScalarColumnCellsStringV(const RefRows &rownrs, const Vector< String > *dataPtr)
virtual void getArrayColumnComplexV(Array< Complex > *dataPtr)
virtual uInt getBlockDComplexV(uInt rownr, uInt nrmax, DComplex *dataPtr)
virtual void putArrayColumnCellsuShortV(const RefRows &rownrs, const Array< uShort > *dataPtr)
virtual void getScalarColumnCellsuIntV(const RefRows &rownrs, Vector< uInt > *dataPtr)
virtual void putColumnSliceuCharV(const Slicer &ns, const Array< uChar > *dataPtr)
virtual void putArrayColumnCellsdoubleV(const RefRows &rownrs, const Array< double > *dataPtr)
virtual void putArrayColumnuCharV(const Array< uChar > *dataPtr)
virtual void putScalarColumnuIntV(const Vector< uInt > *dataPtr)
virtual void getScalarColumnCellsStringV(const RefRows &rownrs, Vector< String > *dataPtr)
virtual void putScalarColumnShortV(const Vector< Short > *dataPtr)
Abstract base class for a column in a data manager.
Definition: DataManager.h:616
virtual void getArrayColumnCellsBoolV(const RefRows &rownrs, Array< Bool > *dataPtr)
Get the array values in some cells of the column.
virtual void putScalarColumnComplexV(const Vector< Complex > *dataPtr)
void getScalarColumnV(void *dataPtr)
Get all scalar values in the column.
virtual void getScalarColumnCellsComplexV(const RefRows &rownrs, Vector< Complex > *dataPtr)
virtual void putArrayColumnfloatV(const Array< float > *dataPtr)
virtual void getArrayColumnCellsdoubleV(const RefRows &rownrs, Array< double > *dataPtr)
virtual void putScalarColumnCellsShortV(const RefRows &rownrs, const Vector< Short > *dataPtr)
virtual void putBlockComplexV(uInt rownr, uInt nrmax, const Complex *dataPtr)
void putScalarColumnCellsV(const RefRows &rownrs, const void *dataPtr)
Put some scalar values in the column.
virtual void getColumnSliceCellsdoubleV(const RefRows &rownrs, const Slicer &ns, Array< double > *dataPtr)
virtual void putArrayColumnIntV(const Array< Int > *dataPtr)
unsigned char uChar
Definition: aipstype.h:44
virtual void putScalarColumndoubleV(const Vector< double > *dataPtr)
virtual void putSliceShortV(uInt rownr, const Slicer &ns, const Array< Short > *dataPtr)
void getSliceV(uInt rownr, const Slicer &slicer, void *dataPtr)
Get a section of the array in the given row.
virtual void putArrayColumnCellsuCharV(const RefRows &rownrs, const Array< uChar > *dataPtr)
virtual void getArrayColumnuIntV(Array< uInt > *dataPtr)
virtual void getScalarColumnuCharV(Vector< uChar > *dataPtr)
void getColumnSliceV(const Slicer &slicer, void *dataPtr)
Get a section of all arrays in the column.
virtual void putColumnSliceCellsfloatV(const RefRows &rownrs, const Slicer &ns, const Array< float > *dataPtr)
virtual void getScalarColumnCellsDComplexV(const RefRows &rownrs, Vector< DComplex > *dataPtr)
virtual void putArrayuIntV(uInt rownr, const Array< uInt > *dataPtr)
virtual uInt getBlockComplexV(uInt rownr, uInt nrmax, Complex *dataPtr)
virtual void getScalarColumnfloatV(Vector< float > *dataPtr)
virtual void putArrayComplexV(uInt rownr, const Array< Complex > *dataPtr)
virtual void putScalarColumnCellsuIntV(const RefRows &rownrs, const Vector< uInt > *dataPtr)
StManColumn & operator=(const StManColumn &)
The object cannot be assigned to.
virtual void getSliceDComplexV(uInt rownr, const Slicer &ns, Array< DComplex > *dataPtr)
Bool canAccessScalarColumn(Bool &reask) const
By default the storage manager can handle access to a scalar column.
virtual void getArrayuIntV(uInt rownr, Array< uInt > *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 getScalarColumnComplexV(Vector< Complex > *dataPtr)
virtual void putScalarColumnStringV(const Vector< String > *dataPtr)
virtual void getScalarColumnShortV(Vector< Short > *dataPtr)
virtual void getArrayColumnCellsuCharV(const RefRows &rownrs, Array< uChar > *dataPtr)
virtual void putScalarColumnBoolV(const Vector< Bool > *dataPtr)
Put the scalar values into the entire column.
virtual void putScalarColumnDComplexV(const Vector< DComplex > *dataPtr)
virtual void putSliceIntV(uInt rownr, const Slicer &ns, const Array< Int > *dataPtr)
void getArrayColumnCellsV(const RefRows &rownrs, void *dataPtr)
Get some array values in the column.
virtual void getScalarColumndoubleV(Vector< double > *dataPtr)
virtual void putArrayBoolV(uInt rownr, const Array< Bool > *dataPtr)
Put the array value into the given row.
virtual void putColumnSliceCellsDComplexV(const RefRows &rownrs, const Slicer &ns, const Array< DComplex > *dataPtr)
int dataType() const
Return the data type of the column.
virtual void putBlockIntV(uInt rownr, uInt nrmax, const Int *dataPtr)
virtual void putSliceBoolV(uInt rownr, const Slicer &ns, const Array< Bool > *dataPtr)
Put the array value into the given row.
virtual void getScalarColumnCellsShortV(const RefRows &rownrs, Vector< Short > *dataPtr)
virtual void putArrayColumnuShortV(const Array< uShort > *dataPtr)
virtual void putBlockuCharV(uInt rownr, uInt nrmax, const uChar *dataPtr)
virtual void getColumnSliceCellsShortV(const RefRows &rownrs, const Slicer &ns, Array< Short > *dataPtr)
virtual uInt getBlockuIntV(uInt rownr, uInt nrmax, uInt *dataPtr)
virtual void getSliceuIntV(uInt rownr, const Slicer &ns, Array< uInt > *dataPtr)
short Short
Definition: aipstype.h:45
virtual void getArrayuShortV(uInt rownr, Array< uShort > *dataPtr)
virtual void putColumnSliceCellsShortV(const RefRows &rownrs, const Slicer &ns, const Array< Short > *dataPtr)
virtual void putArrayStringV(uInt rownr, const Array< String > *dataPtr)
virtual void getColumnSliceCellsStringV(const RefRows &rownrs, const Slicer &ns, Array< String > *dataPtr)
virtual void putBlockfloatV(uInt rownr, uInt nrmax, const float *dataPtr)
virtual void getSliceIntV(uInt rownr, const Slicer &ns, Array< Int > *dataPtr)
virtual void putColumnSliceStringV(const Slicer &ns, const Array< String > *dataPtr)
virtual void putScalarColumnfloatV(const Vector< float > *dataPtr)
virtual void putArrayColumnCellsDComplexV(const RefRows &rownrs, const Array< DComplex > *dataPtr)
virtual void putScalarColumnCellsuShortV(const RefRows &rownrs, const Vector< uShort > *dataPtr)
virtual void getColumnSliceuCharV(const Slicer &ns, Array< uChar > *dataPtr)
virtual void putSliceStringV(uInt rownr, const Slicer &ns, const Array< String > *dataPtr)
virtual void getScalarColumnBoolV(Vector< Bool > *dataPtr)
Get the scalar values in the entire column.
virtual void getColumnSliceShortV(const Slicer &ns, Array< Short > *dataPtr)
virtual void putBlockBoolV(uInt rownr, uInt nrmax, const Bool *dataPtr)
Put nrmax scalars from the given row on.
virtual void getArrayColumnCellsDComplexV(const RefRows &rownrs, Array< DComplex > *dataPtr)
virtual void getSlicedoubleV(uInt rownr, const Slicer &ns, Array< double > *dataPtr)
virtual void putSliceuCharV(uInt rownr, const Slicer &ns, const Array< uChar > *dataPtr)
virtual void getSliceStringV(uInt rownr, const Slicer &ns, Array< String > *dataPtr)
virtual void putColumnSliceCellsIntV(const RefRows &rownrs, const Slicer &ns, const Array< Int > *dataPtr)
void putArrayColumnV(const void *dataPtr)
Put all array values in the column.
virtual void putArrayfloatV(uInt rownr, const Array< float > *dataPtr)
virtual void getColumnSliceCellsuCharV(const RefRows &rownrs, const Slicer &ns, Array< uChar > *dataPtr)
virtual void putColumnSlicefloatV(const Slicer &ns, const Array< float > *dataPtr)
virtual void putArrayColumnCellsComplexV(const RefRows &rownrs, const Array< Complex > *dataPtr)
virtual void putArrayColumnCellsuIntV(const RefRows &rownrs, const Array< uInt > *dataPtr)
virtual void getColumnSliceIntV(const Slicer &ns, Array< Int > *dataPtr)
virtual void putArrayColumnCellsShortV(const RefRows &rownrs, const Array< Short > *dataPtr)
virtual uInt getBlockfloatV(uInt rownr, uInt nrmax, float *dataPtr)
virtual void putSlicefloatV(uInt rownr, const Slicer &ns, const Array< float > *dataPtr)
virtual void getColumnSliceBoolV(const Slicer &ns, Array< Bool > *dataPtr)
Get the array values in the entire column.
void throwGetArray() const
Throw an "invalid operation" exception for the default implementation of getArray.
virtual void getSliceShortV(uInt rownr, const Slicer &ns, Array< Short > *dataPtr)
virtual void putColumnSliceCellsuCharV(const RefRows &rownrs, const Slicer &ns, const Array< uChar > *dataPtr)
virtual void getScalarColumnIntV(Vector< Int > *dataPtr)
virtual void putColumnSliceIntV(const Slicer &ns, const Array< Int > *dataPtr)
virtual void getSlicefloatV(uInt rownr, const Slicer &ns, Array< float > *dataPtr)
void putColumnSliceV(const Slicer &slicer, const void *dataPtr)
Put into a section of all arrays in the column.
virtual void putArrayColumnCellsIntV(const RefRows &rownrs, const Array< Int > *dataPtr)
virtual void putScalarColumnCellsComplexV(const RefRows &rownrs, const Vector< Complex > *dataPtr)
void putArrayV(uInt rownr, const void *dataPtr)
Put the array value into the given row.
virtual void getArrayuCharV(uInt rownr, Array< uChar > *dataPtr)
Class holding the row numbers in a RefTable.
Definition: RefRows.h:85
virtual void getArrayBoolV(uInt rownr, Array< Bool > *dataPtr)
Get the array value in the given row.
virtual void getScalarColumnCellsuCharV(const RefRows &rownrs, Vector< uChar > *dataPtr)
virtual void getScalarColumnStringV(Vector< String > *dataPtr)
virtual void getSliceComplexV(uInt rownr, const Slicer &ns, Array< Complex > *dataPtr)
virtual void getArrayColumnIntV(Array< Int > *dataPtr)
void throwPutArray() const
Throw an "invalid operation" exception for the default implementation of putArray.
virtual void putArrayuCharV(uInt rownr, const Array< uChar > *dataPtr)
virtual void putScalarColumnCellsfloatV(const RefRows &rownrs, const Vector< float > *dataPtr)
virtual void getArrayColumnCellsuShortV(const RefRows &rownrs, Array< uShort > *dataPtr)
virtual void putScalarColumnCellsBoolV(const RefRows &rownrs, const Vector< Bool > *dataPtr)
Put the scalar values into some cells of the column.
uInt getBlockV(uInt rownr, uInt nrmax, void *dataPtr)
Get scalars from the given row on with a maximum of nrmax values.
virtual void putBlockStringV(uInt rownr, uInt nrmax, const String *dataPtr)
virtual void getArraydoubleV(uInt rownr, Array< double > *dataPtr)
virtual void getColumnSliceCellsDComplexV(const RefRows &rownrs, const Slicer &ns, Array< DComplex > *dataPtr)
virtual void putColumnSliceCellsComplexV(const RefRows &rownrs, const Slicer &ns, const Array< Complex > *dataPtr)
virtual void putBlockdoubleV(uInt rownr, uInt nrmax, const double *dataPtr)
virtual uInt getBlockShortV(uInt rownr, uInt nrmax, Short *dataPtr)
virtual void getArrayColumnStringV(Array< String > *dataPtr)
virtual void getArrayColumnuCharV(Array< uChar > *dataPtr)
Bool canAccessArrayColumnCells(Bool &reask) const
All storage managers can handle access to array column cells, because this class contains a default i...
virtual void putColumnSliceCellsdoubleV(const RefRows &rownrs, const Slicer &ns, const Array< double > *dataPtr)
bool Bool
Define the standard types used by Casacore.
Definition: aipstype.h:39
virtual void putArrayColumnCellsStringV(const RefRows &rownrs, const Array< String > *dataPtr)
virtual void getScalarColumnuShortV(Vector< uShort > *dataPtr)
virtual void getArrayColumnBoolV(Array< Bool > *dataPtr)
Get the array values in the entire column.
virtual void putArrayColumnShortV(const Array< Short > *dataPtr)
virtual uInt getBlockIntV(uInt rownr, uInt nrmax, Int *dataPtr)
void getScalarColumnCellsV(const RefRows &rownrs, void *dataPtr)
Get some scalar values in the column.
virtual void getSliceuShortV(uInt rownr, const Slicer &ns, Array< uShort > *dataPtr)
virtual void putColumnSliceCellsStringV(const RefRows &rownrs, const Slicer &ns, const Array< String > *dataPtr)
virtual void putColumnSlicedoubleV(const Slicer &ns, const Array< double > *dataPtr)
virtual void getColumnSliceCellsuShortV(const RefRows &rownrs, const Slicer &ns, Array< uShort > *dataPtr)
virtual void getArrayColumnCellsComplexV(const RefRows &rownrs, Array< Complex > *dataPtr)
virtual void getScalarColumnCellsIntV(const RefRows &rownrs, Vector< Int > *dataPtr)
virtual void getArrayShortV(uInt rownr, Array< Short > *dataPtr)
virtual void getColumnSliceDComplexV(const Slicer &ns, Array< DComplex > *dataPtr)
virtual void getArrayColumnfloatV(Array< float > *dataPtr)
virtual void getColumnSliceStringV(const Slicer &ns, Array< String > *dataPtr)
virtual void putColumnSliceDComplexV(const Slicer &ns, const Array< DComplex > *dataPtr)
virtual void putScalarColumnCellsDComplexV(const RefRows &rownrs, const Vector< DComplex > *dataPtr)
virtual void putScalarColumnCellsdoubleV(const RefRows &rownrs, const Vector< double > *dataPtr)
virtual void getArrayDComplexV(uInt rownr, Array< DComplex > *dataPtr)
virtual void putScalarColumnCellsuCharV(const RefRows &rownrs, const Vector< uChar > *dataPtr)
StManColumn(int dataType)
Default constructor.
virtual void putSliceComplexV(uInt rownr, const Slicer &ns, const Array< Complex > *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 void putArrayColumnComplexV(const Array< Complex > *dataPtr)
Specify which elements to extract from an n-dimensional array.
Definition: Slicer.h:275
virtual void putColumnSliceuShortV(const Slicer &ns, const Array< uShort > *dataPtr)
virtual uInt getBlockdoubleV(uInt rownr, uInt nrmax, double *dataPtr)
virtual void getArrayComplexV(uInt rownr, Array< Complex > *dataPtr)
virtual void getColumnSlicedoubleV(const Slicer &ns, Array< double > *dataPtr)
virtual void getArrayIntV(uInt rownr, Array< Int > *dataPtr)
virtual void putBlockDComplexV(uInt rownr, uInt nrmax, const DComplex *dataPtr)
virtual uInt getBlockuCharV(uInt rownr, uInt nrmax, uChar *dataPtr)
virtual void getArrayfloatV(uInt rownr, Array< float > *dataPtr)
virtual void putBlockShortV(uInt rownr, uInt nrmax, const Short *dataPtr)
virtual void putSliceuIntV(uInt rownr, const Slicer &ns, const Array< uInt > *dataPtr)
virtual void getArrayColumndoubleV(Array< double > *dataPtr)
void putSliceV(uInt rownr, const Slicer &slicer, const void *dataPtr)
Put into a section of the array in the given row.
virtual void getArrayColumnCellsStringV(const RefRows &rownrs, Array< String > *dataPtr)
virtual uInt getBlockBoolV(uInt rownr, uInt nrmax, Bool *dataPtr)
Get scalars from the given row on with a maximum of nrmax values.
virtual void putColumnSliceCellsV(const RefRows &rownrs, const Slicer &slicer, const void *dataPtr)
Put into a section of some arrays in the column.
virtual void getScalarColumnDComplexV(Vector< DComplex > *dataPtr)
void putArrayColumnCellsV(const RefRows &rownrs, const void *dataPtr)
Put some array values in the column.
virtual void putArrayDComplexV(uInt rownr, const Array< DComplex > *dataPtr)
virtual void getColumnSliceCellsuIntV(const RefRows &rownrs, const Slicer &ns, Array< uInt > *dataPtr)
virtual void getScalarColumnCellsuShortV(const RefRows &rownrs, Vector< uShort > *dataPtr)
virtual void getColumnSliceComplexV(const Slicer &ns, Array< Complex > *dataPtr)
void getArrayV(uInt rownr, void *dataPtr)
Get the array value in the given row.
virtual void getColumnSliceCellsIntV(const RefRows &rownrs, const Slicer &ns, Array< Int > *dataPtr)
virtual void getArrayColumnDComplexV(Array< DComplex > *dataPtr)
virtual void putColumnSliceuIntV(const Slicer &ns, const Array< uInt > *dataPtr)
virtual void getScalarColumnCellsfloatV(const RefRows &rownrs, Vector< float > *dataPtr)
Bool canAccessScalarColumnCells(Bool &reask) const
All storage managers can handle access to scalar column cells, because this class contains a default ...
String: the storage and methods of handling collections of characters.
Definition: String.h:223
virtual void putSliceDComplexV(uInt rownr, const Slicer &ns, const Array< DComplex > *dataPtr)
void putBlockV(uInt rownr, uInt nrmax, const void *dataPtr)
Put nrmax scalars from the given row on.
virtual void putColumnSliceComplexV(const Slicer &ns, const Array< Complex > *dataPtr)
virtual void getSliceBoolV(uInt rownr, const Slicer &ns, Array< Bool > *dataPtr)
Get the array value in the given row.
virtual void getScalarColumnuIntV(Vector< uInt > *dataPtr)
virtual void putScalarColumnuCharV(const Vector< uChar > *dataPtr)
virtual void getColumnSlicefloatV(const Slicer &ns, Array< float > *dataPtr)
virtual void putArrayColumnBoolV(const Array< Bool > *dataPtr)
Put the array values into the entire column.
virtual void putColumnSliceBoolV(const Slicer &ns, const Array< Bool > *dataPtr)
Put the array values into the entire column.
virtual void putBlockuShortV(uInt rownr, uInt nrmax, const uShort *dataPtr)
virtual uInt getBlockuShortV(uInt rownr, uInt nrmax, uShort *dataPtr)
virtual void putBlockuIntV(uInt rownr, uInt nrmax, const uInt *dataPtr)
Base table column storage manager class.
Definition: StManColumn.h:102
virtual void putScalarColumnuShortV(const Vector< uShort > *dataPtr)
virtual void putArrayColumnuIntV(const Array< uInt > *dataPtr)
int dtype_p
The data type of the column.
Definition: StManColumn.h:793
virtual void putArrayIntV(uInt rownr, const Array< Int > *dataPtr)
virtual void putScalarColumnIntV(const Vector< Int > *dataPtr)
virtual void putSlicedoubleV(uInt rownr, const Slicer &ns, const Array< double > *dataPtr)
this file contains all the compiler specific defines
Definition: mainpage.dox:28
virtual void getScalarColumnCellsdoubleV(const RefRows &rownrs, Vector< double > *dataPtr)
virtual void getScalarColumnCellsBoolV(const RefRows &rownrs, Vector< Bool > *dataPtr)
Get the scalar values in some cells of the column.
virtual void getArrayColumnCellsShortV(const RefRows &rownrs, Array< Short > *dataPtr)
virtual void getArrayColumnCellsfloatV(const RefRows &rownrs, Array< float > *dataPtr)
virtual void getColumnSliceCellsfloatV(const RefRows &rownrs, const Slicer &ns, Array< float > *dataPtr)
virtual void putArrayuShortV(uInt rownr, const Array< uShort > *dataPtr)
virtual void putSliceuShortV(uInt rownr, const Slicer &ns, const Array< uShort > *dataPtr)
virtual void putScalarColumnCellsIntV(const RefRows &rownrs, const Vector< Int > *dataPtr)
virtual void getColumnSliceuIntV(const Slicer &ns, Array< uInt > *dataPtr)
virtual void putArrayColumnCellsfloatV(const RefRows &rownrs, const Array< float > *dataPtr)
unsigned int uInt
Definition: aipstype.h:48
void getArrayColumnV(void *dataPtr)
Get all array values in the column.
virtual void getSliceuCharV(uInt rownr, const Slicer &ns, Array< uChar > *dataPtr)
unsigned short uShort
Definition: aipstype.h:46
virtual void putArraydoubleV(uInt rownr, const Array< double > *dataPtr)
virtual void getArrayColumnuShortV(Array< uShort > *dataPtr)
virtual void putArrayColumndoubleV(const Array< double > *dataPtr)
void putScalarColumnV(const void *dataPtr)
Put all scalar values in the column.