casacore
TSMDataColumn.h
Go to the documentation of this file.
1 //# TSMDataColumn.h: A data column in Tiled Storage Manager
2 //# Copyright (C) 1995,1996,1997,1999,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_TSMDATACOLUMN_H
29 #define TABLES_TSMDATACOLUMN_H
30 
31 
32 //# Includes
33 #include <casacore/casa/aips.h>
34 #include <casacore/tables/DataMan/TSMColumn.h>
35 #include <casacore/tables/DataMan/TSMCube.h>
36 #include <casacore/casa/BasicSL/Complex.h>
37 #include <casacore/casa/Arrays/IPosition.h>
38 #include <casacore/casa/BasicSL/String.h>
39 #include <casacore/casa/OS/Conversion.h>
40 
41 namespace casacore { //# NAMESPACE CASACORE - BEGIN
42 
43 //# Forward Declarations
44 class Slicer;
45 
46 
47 // <summary>
48 // A data column in Tiled Storage Manager.
49 // </summary>
50 
51 // <use visibility=local>
52 
53 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
54 // </reviewed>
55 
56 // <prerequisite>
57 //# Classes you should understand before using this one.
58 // <li> <linkto class=TSMColumn>TSMColumn</linkto>
59 // <li> <linkto class=TSMCube>TSMCube</linkto>
60 // </prerequisite>
61 
62 // <etymology>
63 // TSMDataColumn handles a data column for a Tiled
64 // Storage Manager.
65 // </etymology>
66 
67 // <synopsis>
68 // TSMDataColumn is used by
69 // <linkto class=TiledStMan>TiledStMan</linkto>
70 // to handle the access to
71 // a table column containing data of a tiled hypercube axis.
72 // The data in a cell can be a scalar or an array (depending on its
73 // definition in the table column description).
74 // The shapes of the coordinates and the data are related. Therefore
75 // the function setShape checks if the data shape matches the coordinates
76 // shape.
77 // <p>
78 // The data are held in a TSMCube object. The row number
79 // determines which TSMCube object has to be accessed.
80 // <p>
81 // The creation of a TSMDataColumn object is done by a TSMColumn object.
82 // This process is described in more detail in the class
83 // <linkto class=TSMColumn>TSMColumn</linkto>.
84 // </synopsis>
85 
86 // <motivation>
87 // Handling data columns in the Tiled Storage Manager is
88 // different from other columns.
89 // </motivation>
90 
91 //# <todo asof="$DATE:$">
92 //# A List of bugs, limitations, extensions or planned refinements.
93 //# </todo>
94 
95 
96 class TSMDataColumn : public TSMColumn
97 {
98 public:
99 
100  // Create a data column from the given column.
101  TSMDataColumn (const TSMColumn& column);
102 
103  // Frees up the storage.
104  virtual ~TSMDataColumn();
105 
106  // Return the size of a pixel in the tile in external format.
107  uInt tilePixelSize() const;
108 
109  // Return the size of a pixel in the tile in local format.
110  uInt localPixelSize() const;
111 
112  // Determine the length to store the given number of pixels.
113  uInt dataLength (uInt nrPixels) const;
114 
115  // Set column sequence number.
116  void setColumnNumber (uInt colnr);
117 
118  // It can handle access to a scalar column if there is one hypercube.
119  Bool canAccessScalarColumn (Bool& reask) const;
120 
121  // It can handle access to an array column if there is one hypercube.
122  Bool canAccessArrayColumn (Bool& reask) const;
123 
124  // It can handle access to a slice in a cell.
125  Bool canAccessSlice (Bool& reask) const;
126 
127  // It can handle access to a slice in column if there is one hypercube.
128  Bool canAccessColumnSlice (Bool& reask) const;
129 
130  // Changing array shapes for non-FixedShape columns when the
131  // parent tiled storage manager can handle it.
132  Bool canChangeShape() const;
133 
134  // Set the shape of the data array in the given row.
135  // It will check if it matches already defined data and coordinates shapes.
136  // It will define undefined data and coordinates shapes.
137  void setShape (uInt rownr, const IPosition& shape);
138 
139  // Set the shape and tile shape of the array in the given row.
140  // It will check if it matches already defined data and coordinates shapes.
141  // It will define undefined data and coordinates shapes.
142  // The tile shape is adjusted to the array shape (size 0 gets set to 1;
143  // size > cubesize gets set to the cubesize).
144  void setShapeTiled (uInt rownr, const IPosition& shape,
145  const IPosition& tileShape);
146 
147  // Is the value shape defined in the given row?
148  Bool isShapeDefined (uInt rownr);
149 
150  // Get the shape of the item in the given row.
151  IPosition shape (uInt rownr);
152 
153  // Get the tile shape of the item in the given row.
154  IPosition tileShape (uInt rownr);
155 
156  // Get a scalar value in the given row.
157  // The buffer pointed to by dataPtr has to have the correct length
158  // (which is guaranteed by the Scalar/ArrayColumn get function).
159  // <group>
160  void getBoolV (uInt rownr, Bool* dataPtr);
161  void getuCharV (uInt rownr, uChar* dataPtr);
162  void getShortV (uInt rownr, Short* dataPtr);
163  void getuShortV (uInt rownr, uShort* dataPtr);
164  void getIntV (uInt rownr, Int* dataPtr);
165  void getuIntV (uInt rownr, uInt* dataPtr);
166  void getfloatV (uInt rownr, float* dataPtr);
167  void getdoubleV (uInt rownr, double* dataPtr);
168  void getComplexV (uInt rownr, Complex* dataPtr);
169  void getDComplexV (uInt rownr, DComplex* dataPtr);
170  // </group>
171 
172  // Put a scalar value into the given row.
173  // The buffer pointed to by dataPtr has to have the correct length
174  // (which is guaranteed by the Scalar/ArrayColumn put function).
175  // <group>
176  void putBoolV (uInt rownr, const Bool* dataPtr);
177  void putuCharV (uInt rownr, const uChar* dataPtr);
178  void putShortV (uInt rownr, const Short* dataPtr);
179  void putuShortV (uInt rownr, const uShort* dataPtr);
180  void putIntV (uInt rownr, const Int* dataPtr);
181  void putuIntV (uInt rownr, const uInt* dataPtr);
182  void putfloatV (uInt rownr, const float* dataPtr);
183  void putdoubleV (uInt rownr, const double* dataPtr);
184  void putComplexV (uInt rownr, const Complex* dataPtr);
185  void putDComplexV (uInt rownr, const DComplex* dataPtr);
186  // </group>
187 
188  // Get the array value in the given row.
189  // The array pointed to by dataPtr has to have the correct length
190  // (which is guaranteed by the ArrayColumn get function).
191  // The default implementation thrown an "invalid operation exception".
192  // <group>
193  void getArrayBoolV (uInt rownr, Array<Bool>* dataPtr);
194  void getArrayuCharV (uInt rownr, Array<uChar>* dataPtr);
195  void getArrayShortV (uInt rownr, Array<Short>* dataPtr);
196  void getArrayuShortV (uInt rownr, Array<uShort>* dataPtr);
197  void getArrayIntV (uInt rownr, Array<Int>* dataPtr);
198  void getArrayuIntV (uInt rownr, Array<uInt>* dataPtr);
199  void getArrayfloatV (uInt rownr, Array<float>* dataPtr);
200  void getArraydoubleV (uInt rownr, Array<double>* dataPtr);
201  void getArrayComplexV (uInt rownr, Array<Complex>* dataPtr);
202  void getArrayDComplexV (uInt rownr, Array<DComplex>* dataPtr);
203  // </group>
204 
205  // Put the array value into the given row.
206  // The buffer pointed to by dataPtr has to have the correct length
207  // (which is guaranteed by the ArrayColumn put function).
208  // The default implementation thrown an "invalid operation exception".
209  // <group>
210  void putArrayBoolV (uInt rownr, const Array<Bool>* dataPtr);
211  void putArrayuCharV (uInt rownr, const Array<uChar>* dataPtr);
212  void putArrayShortV (uInt rownr, const Array<Short>* dataPtr);
213  void putArrayuShortV (uInt rownr, const Array<uShort>* dataPtr);
214  void putArrayIntV (uInt rownr, const Array<Int>* dataPtr);
215  void putArrayuIntV (uInt rownr, const Array<uInt>* dataPtr);
216  void putArrayfloatV (uInt rownr, const Array<float>* dataPtr);
217  void putArraydoubleV (uInt rownr, const Array<double>* dataPtr);
218  void putArrayComplexV (uInt rownr, const Array<Complex>* dataPtr);
219  void putArrayDComplexV (uInt rownr, const Array<DComplex>* dataPtr);
220  // </group>
221 
222  void getSliceBoolV (uInt rownr, const Slicer& slicer,
223  Array<Bool>* dataPtr);
224  void getSliceuCharV (uInt rownr, const Slicer& slicer,
225  Array<uChar>* dataPtr);
226  void getSliceShortV (uInt rownr, const Slicer& slicer,
227  Array<Short>* dataPtr);
228  void getSliceuShortV (uInt rownr, const Slicer& slicer,
229  Array<uShort>* dataPtr);
230  void getSliceIntV (uInt rownr, const Slicer& slicer,
231  Array<Int>* dataPtr);
232  void getSliceuIntV (uInt rownr, const Slicer& slicer,
233  Array<uInt>* dataPtr);
234  void getSlicefloatV (uInt rownr, const Slicer& slicer,
235  Array<float>* dataPtr);
236  void getSlicedoubleV (uInt rownr, const Slicer& slicer,
237  Array<double>* dataPtr);
238  void getSliceComplexV (uInt rownr, const Slicer& slicer,
239  Array<Complex>* dataPtr);
240  void getSliceDComplexV (uInt rownr, const Slicer& slicer,
241  Array<DComplex>* dataPtr);
242 
243  void putSliceBoolV (uInt rownr, const Slicer& slicer,
244  const Array<Bool>* dataPtr);
245  void putSliceuCharV (uInt rownr, const Slicer& slicer,
246  const Array<uChar>* dataPtr);
247  void putSliceShortV (uInt rownr, const Slicer& slicer,
248  const Array<Short>* dataPtr);
249  void putSliceuShortV (uInt rownr, const Slicer& slicer,
250  const Array<uShort>* dataPtr);
251  void putSliceIntV (uInt rownr, const Slicer& slicer,
252  const Array<Int>* dataPtr);
253  void putSliceuIntV (uInt rownr, const Slicer& slicer,
254  const Array<uInt>* dataPtr);
255  void putSlicefloatV (uInt rownr, const Slicer& slicer,
256  const Array<float>* dataPtr);
257  void putSlicedoubleV (uInt rownr, const Slicer& slicer,
258  const Array<double>* dataPtr);
259  void putSliceComplexV (uInt rownr, const Slicer& slicer,
260  const Array<Complex>* dataPtr);
261  void putSliceDComplexV (uInt rownr, const Slicer& slicer,
262  const Array<DComplex>* dataPtr);
263 
268  void getScalarColumnIntV (Vector<Int>* arr);
274 
275  void putScalarColumnBoolV (const Vector<Bool>* arr);
276  void putScalarColumnuCharV (const Vector<uChar>* arr);
277  void putScalarColumnShortV (const Vector<Short>* arr);
278  void putScalarColumnuShortV (const Vector<uShort>* arr);
279  void putScalarColumnIntV (const Vector<Int>* arr);
280  void putScalarColumnuIntV (const Vector<uInt>* arr);
281  void putScalarColumnfloatV (const Vector<float>* arr);
282  void putScalarColumndoubleV (const Vector<double>* arr);
283  void putScalarColumnComplexV (const Vector<Complex>* arr);
284  void putScalarColumnDComplexV (const Vector<DComplex>* arr);
285 
286  // Get the scalar values in some cells of the column.
287  // The buffer pointed to by dataPtr has to have the correct length.
288  // (which is guaranteed by the ScalarColumn getColumnCells function).
289  // The default implementation loops through all rows.
290  // <group>
291  virtual void getScalarColumnCellsBoolV (const RefRows& rownrs,
292  Vector<Bool>* dataPtr);
293  virtual void getScalarColumnCellsuCharV (const RefRows& rownrs,
294  Vector<uChar>* dataPtr);
295  virtual void getScalarColumnCellsShortV (const RefRows& rownrs,
296  Vector<Short>* dataPtr);
297  virtual void getScalarColumnCellsuShortV (const RefRows& rownrs,
298  Vector<uShort>* dataPtr);
299  virtual void getScalarColumnCellsIntV (const RefRows& rownrs,
300  Vector<Int>* dataPtr);
301  virtual void getScalarColumnCellsuIntV (const RefRows& rownrs,
302  Vector<uInt>* dataPtr);
303  virtual void getScalarColumnCellsfloatV (const RefRows& rownrs,
304  Vector<float>* dataPtr);
305  virtual void getScalarColumnCellsdoubleV (const RefRows& rownrs,
306  Vector<double>* dataPtr);
307  virtual void getScalarColumnCellsComplexV (const RefRows& rownrs,
308  Vector<Complex>* dataPtr);
309  virtual void getScalarColumnCellsDComplexV (const RefRows& rownrs,
310  Vector<DComplex>* dataPtr);
311  // </group>
312 
313  // Put the scalar values into some cells of the column.
314  // The buffer pointed to by dataPtr has to have the correct length.
315  // (which is guaranteed by the ScalarColumn putColumnCells function).
316  // The default implementation loops through all rows.
317  // <group>
318  virtual void putScalarColumnCellsBoolV (const RefRows& rownrs,
319  const Vector<Bool>* dataPtr);
320  virtual void putScalarColumnCellsuCharV (const RefRows& rownrs,
321  const Vector<uChar>* dataPtr);
322  virtual void putScalarColumnCellsShortV (const RefRows& rownrs,
323  const Vector<Short>* dataPtr);
324  virtual void putScalarColumnCellsuShortV (const RefRows& rownrs,
325  const Vector<uShort>* dataPtr);
326  virtual void putScalarColumnCellsIntV (const RefRows& rownrs,
327  const Vector<Int>* dataPtr);
328  virtual void putScalarColumnCellsuIntV (const RefRows& rownrs,
329  const Vector<uInt>* dataPtr);
330  virtual void putScalarColumnCellsfloatV (const RefRows& rownrs,
331  const Vector<float>* dataPtr);
332  virtual void putScalarColumnCellsdoubleV (const RefRows& rownrs,
333  const Vector<double>* dataPtr);
334  virtual void putScalarColumnCellsComplexV (const RefRows& rownrs,
335  const Vector<Complex>* dataPtr);
336  virtual void putScalarColumnCellsDComplexV (const RefRows& rownrs,
337  const Vector<DComplex>* dataPtr);
338  // </group>
339 
340  void getArrayColumnBoolV (Array<Bool>* arr);
344  void getArrayColumnIntV (Array<Int>* arr);
345  void getArrayColumnuIntV (Array<uInt>* arr);
350 
351  void putArrayColumnBoolV (const Array<Bool>* arr);
352  void putArrayColumnuCharV (const Array<uChar>* arr);
353  void putArrayColumnShortV (const Array<Short>* arr);
354  void putArrayColumnuShortV (const Array<uShort>* arr);
355  void putArrayColumnIntV (const Array<Int>* arr);
356  void putArrayColumnuIntV (const Array<uInt>* arr);
357  void putArrayColumnfloatV (const Array<float>* arr);
358  void putArrayColumndoubleV (const Array<double>* arr);
359  void putArrayColumnComplexV (const Array<Complex>* arr);
360  void putArrayColumnDComplexV (const Array<DComplex>* arr);
361 
362  // Get the array values in some cells of the column.
363  // The buffer pointed to by dataPtr has to have the correct length.
364  // (which is guaranteed by the ArrayColumn getColumnCells function).
365  // The default implementation throws an "invalid operation exception".
366  // <group>
367  virtual void getArrayColumnCellsBoolV (const RefRows& rownrs,
368  Array<Bool>* dataPtr);
369  virtual void getArrayColumnCellsuCharV (const RefRows& rownrs,
370  Array<uChar>* dataPtr);
371  virtual void getArrayColumnCellsShortV (const RefRows& rownrs,
372  Array<Short>* dataPtr);
373  virtual void getArrayColumnCellsuShortV (const RefRows& rownrs,
374  Array<uShort>* dataPtr);
375  virtual void getArrayColumnCellsIntV (const RefRows& rownrs,
376  Array<Int>* dataPtr);
377  virtual void getArrayColumnCellsuIntV (const RefRows& rownrs,
378  Array<uInt>* dataPtr);
379  virtual void getArrayColumnCellsfloatV (const RefRows& rownrs,
380  Array<float>* dataPtr);
381  virtual void getArrayColumnCellsdoubleV (const RefRows& rownrs,
382  Array<double>* dataPtr);
383  virtual void getArrayColumnCellsComplexV (const RefRows& rownrs,
384  Array<Complex>* dataPtr);
385  virtual void getArrayColumnCellsDComplexV (const RefRows& rownrs,
386  Array<DComplex>* dataPtr);
387  // </group>
388 
389  // Put the array values into some cells of the column.
390  // The buffer pointed to by dataPtr has to have the correct length.
391  // (which is guaranteed by the ArrayColumn putColumnCells function).
392  // The default implementation throws an "invalid operation exception".
393  // <group>
394  virtual void putArrayColumnCellsBoolV (const RefRows& rownrs,
395  const Array<Bool>* dataPtr);
396  virtual void putArrayColumnCellsuCharV (const RefRows& rownrs,
397  const Array<uChar>* dataPtr);
398  virtual void putArrayColumnCellsShortV (const RefRows& rownrs,
399  const Array<Short>* dataPtr);
400  virtual void putArrayColumnCellsuShortV (const RefRows& rownrs,
401  const Array<uShort>* dataPtr);
402  virtual void putArrayColumnCellsIntV (const RefRows& rownrs,
403  const Array<Int>* dataPtr);
404  virtual void putArrayColumnCellsuIntV (const RefRows& rownrs,
405  const Array<uInt>* dataPtr);
406  virtual void putArrayColumnCellsfloatV (const RefRows& rownrs,
407  const Array<float>* dataPtr);
408  virtual void putArrayColumnCellsdoubleV (const RefRows& rownrs,
409  const Array<double>* dataPtr);
410  virtual void putArrayColumnCellsComplexV (const RefRows& rownrs,
411  const Array<Complex>* dataPtr);
412  virtual void putArrayColumnCellsDComplexV (const RefRows& rownrs,
413  const Array<DComplex>* dataPtr);
414  // </group>
415 
416  void getColumnSliceBoolV (const Slicer& slicer, Array<Bool>* arr);
417  void getColumnSliceuCharV (const Slicer& slicer, Array<uChar>* arr);
418  void getColumnSliceShortV (const Slicer& slicer, Array<Short>* arr);
419  void getColumnSliceuShortV (const Slicer& slicer, Array<uShort>* arr);
420  void getColumnSliceIntV (const Slicer& slicer, Array<Int>* arr);
421  void getColumnSliceuIntV (const Slicer& slicer, Array<uInt>* arr);
422  void getColumnSlicefloatV (const Slicer& slicer, Array<float>* arr);
423  void getColumnSlicedoubleV (const Slicer& slicer, Array<double>* arr);
424  void getColumnSliceComplexV (const Slicer& slicer, Array<Complex>* arr);
425  void getColumnSliceDComplexV (const Slicer& slicer, Array<DComplex>* arr);
426 
427  void putColumnSliceBoolV (const Slicer& slicer,
428  const Array<Bool>* dataPtr);
429  void putColumnSliceuCharV (const Slicer& slicer,
430  const Array<uChar>* dataPtr);
431  void putColumnSliceShortV (const Slicer& slicer,
432  const Array<Short>* dataPtr);
433  void putColumnSliceuShortV (const Slicer& slicer,
434  const Array<uShort>* dataPtr);
435  void putColumnSliceIntV (const Slicer& slicer,
436  const Array<Int>* dataPtr);
437  void putColumnSliceuIntV (const Slicer& slicer,
438  const Array<uInt>* dataPtr);
439  void putColumnSlicefloatV (const Slicer& slicer,
440  const Array<float>* dataPtr);
441  void putColumnSlicedoubleV (const Slicer& slicer,
442  const Array<double>* dataPtr);
443  void putColumnSliceComplexV (const Slicer& slicer,
444  const Array<Complex>* dataPtr);
445  void putColumnSliceDComplexV (const Slicer& slicer,
446  const Array<DComplex>* dataPtr);
447 
448  // Get the array values in some cells of the column.
449  // The buffer pointed to by dataPtr has to have the correct length.
450  // (which is guaranteed by the ArrayColumn getColumnCells function).
451  // The default implementation throws an "invalid operation exception".
452  // <group>
453  virtual void getColumnSliceCellsBoolV (const RefRows& rownrs,
454  const Slicer& ns,
455  Array<Bool>* dataPtr);
456  virtual void getColumnSliceCellsuCharV (const RefRows& rownrs,
457  const Slicer& ns,
458  Array<uChar>* dataPtr);
459  virtual void getColumnSliceCellsShortV (const RefRows& rownrs,
460  const Slicer& ns,
461  Array<Short>* dataPtr);
462  virtual void getColumnSliceCellsuShortV (const RefRows& rownrs,
463  const Slicer& ns,
464  Array<uShort>* dataPtr);
465  virtual void getColumnSliceCellsIntV (const RefRows& rownrs,
466  const Slicer& ns,
467  Array<Int>* dataPtr);
468  virtual void getColumnSliceCellsuIntV (const RefRows& rownrs,
469  const Slicer& ns,
470  Array<uInt>* dataPtr);
471  virtual void getColumnSliceCellsfloatV (const RefRows& rownrs,
472  const Slicer& ns,
473  Array<float>* dataPtr);
474  virtual void getColumnSliceCellsdoubleV (const RefRows& rownrs,
475  const Slicer& ns,
476  Array<double>* dataPtr);
477  virtual void getColumnSliceCellsComplexV (const RefRows& rownrs,
478  const Slicer& ns,
479  Array<Complex>* dataPtr);
480  virtual void getColumnSliceCellsDComplexV (const RefRows& rownrs,
481  const Slicer& ns,
482  Array<DComplex>* dataPtr);
483  // </group>
484 
485  // Put the array values into some cells of the column.
486  // The buffer pointed to by dataPtr has to have the correct length.
487  // (which is guaranteed by the ArrayColumn putColumnSlice function).
488  // The default implementation throws an "invalid operation exception".
489  // <group>
490  virtual void putColumnSliceCellsBoolV (const RefRows& rownrs,
491  const Slicer& ns,
492  const Array<Bool>* dataPtr);
493  virtual void putColumnSliceCellsuCharV (const RefRows& rownrs,
494  const Slicer& ns,
495  const Array<uChar>* dataPtr);
496  virtual void putColumnSliceCellsShortV (const RefRows& rownrs,
497  const Slicer& ns,
498  const Array<Short>* dataPtr);
499  virtual void putColumnSliceCellsuShortV (const RefRows& rownrs,
500  const Slicer& ns,
501  const Array<uShort>* dataPtr);
502  virtual void putColumnSliceCellsIntV (const RefRows& rownrs,
503  const Slicer& ns,
504  const Array<Int>* dataPtr);
505  virtual void putColumnSliceCellsuIntV (const RefRows& rownrs,
506  const Slicer& ns,
507  const Array<uInt>* dataPtr);
508  virtual void putColumnSliceCellsfloatV (const RefRows& rownrs,
509  const Slicer& ns,
510  const Array<float>* dataPtr);
511  virtual void putColumnSliceCellsdoubleV (const RefRows& rownrs,
512  const Slicer& ns,
513  const Array<double>* dataPtr);
514  virtual void putColumnSliceCellsComplexV (const RefRows& rownrs,
515  const Slicer& ns,
516  const Array<Complex>* dataPtr);
517  virtual void putColumnSliceCellsDComplexV (const RefRows& rownrs,
518  const Slicer& ns,
519  const Array<DComplex>* dataPtr);
520  // </group>
521 
522  // Read the data of the column from a tile.
523  // (I.e. convert from external to local format).
524  void readTile (void* to, const void* from, uInt nrPixels);
525 
526  // Write the data of the column into a tile.
527  // (I.e. convert from local to external format).
528  void writeTile (void* to, const void* from, uInt nrPixels);
529 
530  // Get the function to convert from external to local format
531  // (or vice-versa if <src>writeFlag=True</src>).
533  { return writeFlag ? writeFunc_p : readFunc_p; }
534 
535  // Get nr of elements in a value to convert (usually 1, but 2 for Complex).
536  size_t getNrConvert() const
537  { return convPixelSize_p; }
538 
539  // Does a conversion (byte swap) needs to be done?
541  { return mustConvert_p; }
542 
543 private:
544  // The (canonical) size of a pixel in a tile.
546  // The local size of a pixel.
548  // The multiplication factor for a conversion operation.
549  // This is the pixel size when a memcpy can be used, otherwise it is 1.
551  // Is a conversion necessary?
553  // The column sequence number.
555  // The conversion function needed when reading.
557  // The conversion function needed when writing.
559 
560 
561  // Forbid copy constructor.
562  TSMDataColumn (const TSMDataColumn&);
563 
564  // Forbid assignment.
566 
567  // Read or write a data cell in the cube.
568  // A cell can contain a scalar or an array (depending on the
569  // column definition).
570  void accessCell (uInt rownr,
571  const void* dataPtr, Bool writeFlag);
572 
573  // Read or write a slice of a data cell in the cube.
574  void accessCellSlice (uInt rownr, const Slicer& ns,
575  const void* dataPtr, Bool writeFlag);
576 
577  // Read or write an entire column.
578  // This can only be done if one hypercube is used.
579  void accessColumn (const void* dataPtr, Bool writeFlag);
580 
581  // Read or write a slice from the entire column.
582  // This can only be done if one hypercube is used.
583  void accessColumnSlice (const Slicer& ns,
584  const void* dataPtr, Bool writeFlag);
585 
586  // Read or write some cells in a column.
587  // It tries to optimize by looking for regular row strides.
588  void accessColumnCells (const RefRows& rownrs, const IPosition& shape,
589  const void* dataPtr, Bool writeFlag);
590 
591  // Read or write some cells in a column.
592  // It tries to optimize by looking for regular row strides.
593  void accessColumnSliceCells (const RefRows& rownrs, const Slicer& ns,
594  const IPosition& shape,
595  const void* dataPtr, Bool writeFlag);
596 
597  // Read or write the full cells given by start,end,incr.
598  void accessFullCells (TSMCube* hypercube,
599  char* dataPtr, Bool writeFlag,
600  const IPosition& start,
601  const IPosition& end,
602  const IPosition& incr);
603 
604  // Read or write the sliced cells given by start,end,incr.
605  void accessSlicedCells (TSMCube* hypercube,
606  char* dataPtr, Bool writeFlag,
607  const IPosition& start,
608  const IPosition& end,
609  const IPosition& incr);
610 };
611 
612 
614 {
615  return tilePixelSize_p;
616 }
618 {
619  return localPixelSize_p;
620 }
622 {
623  colnr_p = colnr;
624 }
625 inline void TSMDataColumn::readTile (void* to, const void* from,
626  uInt nrPixels)
627 {
628  readFunc_p (to, from, nrPixels * convPixelSize_p);
629 }
630 inline void TSMDataColumn::writeTile (void* to, const void* from,
631  uInt nrPixels)
632 {
633  writeFunc_p (to, from, nrPixels * convPixelSize_p);
634 }
635 
636 
637 
638 } //# NAMESPACE CASACORE - END
639 
640 #endif
virtual void getArrayColumnCellsShortV(const RefRows &rownrs, Array< Short > *dataPtr)
void putColumnSliceShortV(const Slicer &slicer, const Array< Short > *dataPtr)
A Vector of integers, for indexing into Array<T> objects.
Definition: IPosition.h:119
uInt tilePixelSize() const
Return the size of a pixel in the tile in external format.
void putArrayComplexV(uInt rownr, const Array< Complex > *dataPtr)
void accessColumnSlice(const Slicer &ns, const void *dataPtr, Bool writeFlag)
Read or write a slice from the entire column.
void putArrayDComplexV(uInt rownr, const Array< DComplex > *dataPtr)
void accessCell(uInt rownr, const void *dataPtr, Bool writeFlag)
Read or write a data cell in the cube.
Bool isShapeDefined(uInt rownr)
Is the value shape defined in the given row?
int Int
Definition: aipstype.h:50
virtual void getColumnSliceCellsShortV(const RefRows &rownrs, const Slicer &ns, Array< Short > *dataPtr)
void getScalarColumnComplexV(Vector< Complex > *arr)
void putSliceShortV(uInt rownr, const Slicer &slicer, const Array< Short > *dataPtr)
void getuShortV(uInt rownr, uShort *dataPtr)
void putColumnSliceuShortV(const Slicer &slicer, const Array< uShort > *dataPtr)
virtual void getColumnSliceCellsdoubleV(const RefRows &rownrs, const Slicer &ns, Array< double > *dataPtr)
void putArrayuShortV(uInt rownr, const Array< uShort > *dataPtr)
void getColumnSliceuShortV(const Slicer &slicer, Array< uShort > *arr)
virtual void putColumnSliceCellsuCharV(const RefRows &rownrs, const Slicer &ns, const Array< uChar > *dataPtr)
void putScalarColumnBoolV(const Vector< Bool > *arr)
Put the scalar values into the entire column.
virtual void getArrayColumnCellsBoolV(const RefRows &rownrs, Array< Bool > *dataPtr)
Get the array values in some cells of the column.
virtual void getArrayColumnCellsIntV(const RefRows &rownrs, Array< Int > *dataPtr)
TSMDataColumn & operator=(const TSMDataColumn &)
Forbid assignment.
virtual void getColumnSliceCellsDComplexV(const RefRows &rownrs, const Slicer &ns, Array< DComplex > *dataPtr)
virtual void putScalarColumnCellsComplexV(const RefRows &rownrs, const Vector< Complex > *dataPtr)
void getArrayColumnComplexV(Array< Complex > *arr)
void getSliceIntV(uInt rownr, const Slicer &slicer, Array< Int > *dataPtr)
void getArrayColumnShortV(Array< Short > *arr)
Tiled hypercube in a table.
Definition: TSMCube.h:105
void putScalarColumnDComplexV(const Vector< DComplex > *arr)
void getArrayuIntV(uInt rownr, Array< uInt > *dataPtr)
virtual void putArrayColumnCellsuCharV(const RefRows &rownrs, const Array< uChar > *dataPtr)
virtual void getArrayColumnCellsuIntV(const RefRows &rownrs, Array< uInt > *dataPtr)
virtual void putColumnSliceCellsBoolV(const RefRows &rownrs, const Slicer &ns, const Array< Bool > *dataPtr)
Put the array values into some cells of the column.
void getArrayuCharV(uInt rownr, Array< uChar > *dataPtr)
void writeTile(void *to, const void *from, uInt nrPixels)
Write the data of the column into a tile.
void getScalarColumnShortV(Vector< Short > *arr)
void putSliceIntV(uInt rownr, const Slicer &slicer, const Array< Int > *dataPtr)
void getColumnSliceIntV(const Slicer &slicer, Array< Int > *arr)
Bool canAccessArrayColumn(Bool &reask) const
It can handle access to an array column if there is one hypercube.
virtual void getColumnSliceCellsuShortV(const RefRows &rownrs, const Slicer &ns, Array< uShort > *dataPtr)
void putColumnSlicedoubleV(const Slicer &slicer, const Array< double > *dataPtr)
virtual void putScalarColumnCellsIntV(const RefRows &rownrs, const Vector< Int > *dataPtr)
unsigned char uChar
Definition: aipstype.h:47
void putuIntV(uInt rownr, const uInt *dataPtr)
void getSliceDComplexV(uInt rownr, const Slicer &slicer, Array< DComplex > *dataPtr)
virtual void putArrayColumnCellsBoolV(const RefRows &rownrs, const Array< Bool > *dataPtr)
Put the array values into some cells of the column.
virtual void putArrayColumnCellsDComplexV(const RefRows &rownrs, const Array< DComplex > *dataPtr)
void putColumnSliceDComplexV(const Slicer &slicer, const Array< DComplex > *dataPtr)
void putArrayColumndoubleV(const Array< double > *arr)
void putScalarColumnIntV(const Vector< Int > *arr)
void getArrayfloatV(uInt rownr, Array< float > *dataPtr)
void putSliceDComplexV(uInt rownr, const Slicer &slicer, const Array< DComplex > *dataPtr)
virtual void putScalarColumnCellsfloatV(const RefRows &rownrs, const Vector< float > *dataPtr)
virtual void getScalarColumnCellsBoolV(const RefRows &rownrs, Vector< Bool > *dataPtr)
Get the scalar values in some cells of the column.
virtual void getArrayColumnCellsuCharV(const RefRows &rownrs, Array< uChar > *dataPtr)
virtual void putColumnSliceCellsfloatV(const RefRows &rownrs, const Slicer &ns, const Array< float > *dataPtr)
void putArrayColumnDComplexV(const Array< DComplex > *arr)
void getColumnSlicedoubleV(const Slicer &slicer, Array< double > *arr)
virtual void getColumnSliceCellsComplexV(const RefRows &rownrs, const Slicer &ns, Array< Complex > *dataPtr)
void putArrayColumnShortV(const Array< Short > *arr)
void putArrayColumnComplexV(const Array< Complex > *arr)
virtual void putArrayColumnCellsfloatV(const RefRows &rownrs, const Array< float > *dataPtr)
void putSliceuCharV(uInt rownr, const Slicer &slicer, const Array< uChar > *dataPtr)
void accessColumn(const void *dataPtr, Bool writeFlag)
Read or write an entire column.
virtual void getScalarColumnCellsShortV(const RefRows &rownrs, Vector< Short > *dataPtr)
void setColumnNumber(uInt colnr)
Set column sequence number.
void getColumnSlicefloatV(const Slicer &slicer, Array< float > *arr)
virtual void getArrayColumnCellsuShortV(const RefRows &rownrs, Array< uShort > *dataPtr)
void putArrayShortV(uInt rownr, const Array< Short > *dataPtr)
void getArrayColumnBoolV(Array< Bool > *arr)
Get the array values in the entire column.
virtual void getScalarColumnCellsDComplexV(const RefRows &rownrs, Vector< DComplex > *dataPtr)
void putColumnSliceComplexV(const Slicer &slicer, const Array< Complex > *dataPtr)
uInt localPixelSize() const
Return the size of a pixel in the tile in local format.
void getColumnSliceDComplexV(const Slicer &slicer, Array< DComplex > *arr)
void getArrayColumnuShortV(Array< uShort > *arr)
void getColumnSliceBoolV(const Slicer &slicer, Array< Bool > *arr)
Get the array values in the entire column.
void putBoolV(uInt rownr, const Bool *dataPtr)
Put a scalar value into the given row.
void getArrayuShortV(uInt rownr, Array< uShort > *dataPtr)
void putuShortV(uInt rownr, const uShort *dataPtr)
void getSlicedoubleV(uInt rownr, const Slicer &slicer, Array< double > *dataPtr)
void putuCharV(uInt rownr, const uChar *dataPtr)
void getArraydoubleV(uInt rownr, Array< double > *dataPtr)
virtual void getColumnSliceCellsBoolV(const RefRows &rownrs, const Slicer &ns, Array< Bool > *dataPtr)
Get the array values in some cells of the column.
void getArrayBoolV(uInt rownr, Array< Bool > *dataPtr)
Get the array value in the given row.
void getSliceBoolV(uInt rownr, const Slicer &slicer, Array< Bool > *dataPtr)
Get the array value in the given row.
void getArrayDComplexV(uInt rownr, Array< DComplex > *dataPtr)
void getSlicefloatV(uInt rownr, const Slicer &slicer, Array< float > *dataPtr)
short Short
Definition: aipstype.h:48
A data column in Tiled Storage Manager.
Definition: TSMDataColumn.h:96
virtual void getScalarColumnCellsComplexV(const RefRows &rownrs, Vector< Complex > *dataPtr)
void readTile(void *to, const void *from, uInt nrPixels)
Read the data of the column from a tile.
virtual void putColumnSliceCellsuShortV(const RefRows &rownrs, const Slicer &ns, const Array< uShort > *dataPtr)
void putScalarColumnShortV(const Vector< Short > *arr)
void putArrayColumnuCharV(const Array< uChar > *arr)
void putArrayColumnIntV(const Array< Int > *arr)
virtual void getArrayColumnCellsfloatV(const RefRows &rownrs, Array< float > *dataPtr)
void getScalarColumnfloatV(Vector< float > *arr)
void getShortV(uInt rownr, Short *dataPtr)
void putSliceBoolV(uInt rownr, const Slicer &slicer, const Array< Bool > *dataPtr)
Put the array value into the given row.
void getuCharV(uInt rownr, uChar *dataPtr)
void putColumnSliceuIntV(const Slicer &slicer, const Array< uInt > *dataPtr)
virtual void putColumnSliceCellsComplexV(const RefRows &rownrs, const Slicer &ns, const Array< Complex > *dataPtr)
void getColumnSliceuIntV(const Slicer &slicer, Array< uInt > *arr)
void putScalarColumnfloatV(const Vector< float > *arr)
void accessColumnCells(const RefRows &rownrs, const IPosition &shape, const void *dataPtr, Bool writeFlag)
Read or write some cells in a column.
void getfloatV(uInt rownr, float *dataPtr)
virtual void putColumnSliceCellsuIntV(const RefRows &rownrs, const Slicer &ns, const Array< uInt > *dataPtr)
void getArrayColumnIntV(Array< Int > *arr)
void putfloatV(uInt rownr, const float *dataPtr)
void getArrayColumnuCharV(Array< uChar > *arr)
void putSlicefloatV(uInt rownr, const Slicer &slicer, const Array< float > *dataPtr)
virtual void putScalarColumnCellsdoubleV(const RefRows &rownrs, const Vector< double > *dataPtr)
void putColumnSlicefloatV(const Slicer &slicer, const Array< float > *dataPtr)
virtual void putColumnSliceCellsIntV(const RefRows &rownrs, const Slicer &ns, const Array< Int > *dataPtr)
void putSliceuIntV(uInt rownr, const Slicer &slicer, const Array< uInt > *dataPtr)
virtual void putArrayColumnCellsComplexV(const RefRows &rownrs, const Array< Complex > *dataPtr)
void putArraydoubleV(uInt rownr, const Array< double > *dataPtr)
TSMDataColumn(const TSMColumn &column)
Create a data column from the given column.
virtual void getColumnSliceCellsuCharV(const RefRows &rownrs, const Slicer &ns, Array< uChar > *dataPtr)
void putDComplexV(uInt rownr, const DComplex *dataPtr)
virtual void getArrayColumnCellsDComplexV(const RefRows &rownrs, Array< DComplex > *dataPtr)
Bool mustConvert_p
Is a conversion necessary?
Class holding the row numbers in a RefTable.
Definition: RefRows.h:85
void getColumnSliceComplexV(const Slicer &slicer, Array< Complex > *arr)
void getBoolV(uInt rownr, Bool *dataPtr)
Get a scalar value in the given row.
IPosition tileShape(uInt rownr)
Get the tile shape of the item in the given row.
void putColumnSliceuCharV(const Slicer &slicer, const Array< uChar > *dataPtr)
virtual void getScalarColumnCellsuShortV(const RefRows &rownrs, Vector< uShort > *dataPtr)
virtual void putScalarColumnCellsuCharV(const RefRows &rownrs, const Vector< uChar > *dataPtr)
virtual void putScalarColumnCellsDComplexV(const RefRows &rownrs, const Vector< DComplex > *dataPtr)
void accessCellSlice(uInt rownr, const Slicer &ns, const void *dataPtr, Bool writeFlag)
Read or write a slice of a data cell in the cube.
void getSliceShortV(uInt rownr, const Slicer &slicer, Array< Short > *dataPtr)
virtual void putArrayColumnCellsuShortV(const RefRows &rownrs, const Array< uShort > *dataPtr)
bool Bool
Define the standard types used by Casacore.
Definition: aipstype.h:42
virtual void getArrayColumnCellsComplexV(const RefRows &rownrs, Array< Complex > *dataPtr)
void getArrayColumndoubleV(Array< double > *arr)
void getArrayColumnDComplexV(Array< DComplex > *arr)
uInt dataLength(uInt nrPixels) const
Determine the length to store the given number of pixels.
void getColumnSliceShortV(const Slicer &slicer, Array< Short > *arr)
virtual void putScalarColumnCellsShortV(const RefRows &rownrs, const Vector< Short > *dataPtr)
virtual void getScalarColumnCellsuIntV(const RefRows &rownrs, Vector< uInt > *dataPtr)
void putShortV(uInt rownr, const Short *dataPtr)
uInt tilePixelSize_p
The (canonical) size of a pixel in a tile.
A column in the Tiled Storage Manager.
Definition: TSMColumn.h:97
void setShape(uInt rownr, const IPosition &shape)
Set the shape of the data array in the given row.
void getComplexV(uInt rownr, Complex *dataPtr)
virtual void getScalarColumnCellsIntV(const RefRows &rownrs, Vector< Int > *dataPtr)
void getColumnSliceuCharV(const Slicer &slicer, Array< uChar > *arr)
void getScalarColumnuShortV(Vector< uShort > *arr)
void getScalarColumnBoolV(Vector< Bool > *arr)
Get the scalar values in the entire column.
void getScalarColumnDComplexV(Vector< DComplex > *arr)
Bool canAccessColumnSlice(Bool &reask) const
It can handle access to a slice in column if there is one hypercube.
virtual void putColumnSliceCellsDComplexV(const RefRows &rownrs, const Slicer &ns, const Array< DComplex > *dataPtr)
Conversion::ValueFunction * writeFunc_p
The conversion function needed when writing.
size_t getNrConvert() const
Get nr of elements in a value to convert (usually 1, but 2 for Complex).
Bool canChangeShape() const
Changing array shapes for non-FixedShape columns when the parent tiled storage manager can handle it...
void putScalarColumndoubleV(const Vector< double > *arr)
void getArrayIntV(uInt rownr, Array< Int > *dataPtr)
Bool isConversionNeeded() const
Does a conversion (byte swap) needs to be done?
Conversion::ValueFunction * getConvertFunction(Bool writeFlag) const
Get the function to convert from external to local format (or vice-versa if writeFlag=True).
virtual void putScalarColumnCellsBoolV(const RefRows &rownrs, const Vector< Bool > *dataPtr)
Put the scalar values into some cells of the column.
virtual void getColumnSliceCellsIntV(const RefRows &rownrs, const Slicer &ns, Array< Int > *dataPtr)
uInt localPixelSize_p
The local size of a pixel.
void putArrayIntV(uInt rownr, const Array< Int > *dataPtr)
virtual void putColumnSliceCellsShortV(const RefRows &rownrs, const Slicer &ns, const Array< Short > *dataPtr)
Specify which elements to extract from an n-dimensional array.
Definition: Slicer.h:289
Bool canAccessScalarColumn(Bool &reask) const
It can handle access to a scalar column if there is one hypercube.
uInt convPixelSize_p
The multiplication factor for a conversion operation.
Conversion::ValueFunction * readFunc_p
The conversion function needed when reading.
void getSliceComplexV(uInt rownr, const Slicer &slicer, Array< Complex > *dataPtr)
void getScalarColumndoubleV(Vector< double > *arr)
void accessFullCells(TSMCube *hypercube, char *dataPtr, Bool writeFlag, const IPosition &start, const IPosition &end, const IPosition &incr)
Read or write the full cells given by start,end,incr.
virtual void putArrayColumnCellsdoubleV(const RefRows &rownrs, const Array< double > *dataPtr)
void getArrayColumnfloatV(Array< float > *arr)
void putScalarColumnComplexV(const Vector< Complex > *arr)
void putColumnSliceBoolV(const Slicer &slicer, const Array< Bool > *dataPtr)
Put the array values into the entire column.
void getArrayComplexV(uInt rownr, Array< Complex > *dataPtr)
void getSliceuIntV(uInt rownr, const Slicer &slicer, Array< uInt > *dataPtr)
void getArrayColumnuIntV(Array< uInt > *arr)
uInt colnr_p
The column sequence number.
void putArrayColumnuIntV(const Array< uInt > *arr)
void putIntV(uInt rownr, const Int *dataPtr)
void putSliceComplexV(uInt rownr, const Slicer &slicer, const Array< Complex > *dataPtr)
virtual void putArrayColumnCellsShortV(const RefRows &rownrs, const Array< Short > *dataPtr)
void putArrayuIntV(uInt rownr, const Array< uInt > *dataPtr)
virtual void getScalarColumnCellsuCharV(const RefRows &rownrs, Vector< uChar > *dataPtr)
virtual void putScalarColumnCellsuShortV(const RefRows &rownrs, const Vector< uShort > *dataPtr)
void putArrayColumnuShortV(const Array< uShort > *arr)
virtual void getScalarColumnCellsfloatV(const RefRows &rownrs, Vector< float > *dataPtr)
virtual void putScalarColumnCellsuIntV(const RefRows &rownrs, const Vector< uInt > *dataPtr)
void putScalarColumnuIntV(const Vector< uInt > *arr)
void getdoubleV(uInt rownr, double *dataPtr)
void putArrayColumnBoolV(const Array< Bool > *arr)
Put the array values into the entire column.
virtual void putArrayColumnCellsuIntV(const RefRows &rownrs, const Array< uInt > *dataPtr)
void getScalarColumnuIntV(Vector< uInt > *arr)
void getDComplexV(uInt rownr, DComplex *dataPtr)
void getuIntV(uInt rownr, uInt *dataPtr)
void getArrayShortV(uInt rownr, Array< Short > *dataPtr)
virtual void putArrayColumnCellsIntV(const RefRows &rownrs, const Array< Int > *dataPtr)
void accessSlicedCells(TSMCube *hypercube, char *dataPtr, Bool writeFlag, const IPosition &start, const IPosition &end, const IPosition &incr)
Read or write the sliced cells given by start,end,incr.
void getIntV(uInt rownr, Int *dataPtr)
void putArrayColumnfloatV(const Array< float > *arr)
void putComplexV(uInt rownr, const Complex *dataPtr)
void setShapeTiled(uInt rownr, const IPosition &shape, const IPosition &tileShape)
Set the shape and tile shape of the array in the given row.
virtual void getArrayColumnCellsdoubleV(const RefRows &rownrs, Array< double > *dataPtr)
Bool canAccessSlice(Bool &reask) const
It can handle access to a slice in a cell.
virtual void putColumnSliceCellsdoubleV(const RefRows &rownrs, const Slicer &ns, const Array< double > *dataPtr)
void putSliceuShortV(uInt rownr, const Slicer &slicer, const Array< uShort > *dataPtr)
void putArrayuCharV(uInt rownr, const Array< uChar > *dataPtr)
void putSlicedoubleV(uInt rownr, const Slicer &slicer, const Array< double > *dataPtr)
void putArrayfloatV(uInt rownr, const Array< float > *dataPtr)
virtual void getScalarColumnCellsdoubleV(const RefRows &rownrs, Vector< double > *dataPtr)
void getSliceuCharV(uInt rownr, const Slicer &slicer, Array< uChar > *dataPtr)
IPosition shape(uInt rownr)
Get the shape of the item in the given row.
virtual void getColumnSliceCellsfloatV(const RefRows &rownrs, const Slicer &ns, Array< float > *dataPtr)
void putScalarColumnuCharV(const Vector< uChar > *arr)
this file contains all the compiler specific defines
Definition: mainpage.dox:28
void putColumnSliceIntV(const Slicer &slicer, const Array< Int > *dataPtr)
void putScalarColumnuShortV(const Vector< uShort > *arr)
void putdoubleV(uInt rownr, const double *dataPtr)
unsigned int uInt
Definition: aipstype.h:51
virtual ~TSMDataColumn()
Frees up the storage.
size_t ValueFunction(void *to, const void *from, size_t nvalues)
Define the signature of a function converting nvalues values from internal to external format or vice...
Definition: Conversion.h:100
void accessColumnSliceCells(const RefRows &rownrs, const Slicer &ns, const IPosition &shape, const void *dataPtr, Bool writeFlag)
Read or write some cells in a column.
void getSliceuShortV(uInt rownr, const Slicer &slicer, Array< uShort > *dataPtr)
unsigned short uShort
Definition: aipstype.h:49
void getScalarColumnIntV(Vector< Int > *arr)
virtual void getColumnSliceCellsuIntV(const RefRows &rownrs, const Slicer &ns, Array< uInt > *dataPtr)
void getScalarColumnuCharV(Vector< uChar > *arr)
void putArrayBoolV(uInt rownr, const Array< Bool > *dataPtr)
Put the array value into the given row.