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 a scalar value in the given row.
154  // The buffer pointed to by dataPtr has to have the correct length
155  // (which is guaranteed by the Scalar/ArrayColumn get function).
156  // <group>
157  void getBoolV (uInt rownr, Bool* dataPtr);
158  void getuCharV (uInt rownr, uChar* dataPtr);
159  void getShortV (uInt rownr, Short* dataPtr);
160  void getuShortV (uInt rownr, uShort* dataPtr);
161  void getIntV (uInt rownr, Int* dataPtr);
162  void getuIntV (uInt rownr, uInt* dataPtr);
163  void getfloatV (uInt rownr, float* dataPtr);
164  void getdoubleV (uInt rownr, double* dataPtr);
165  void getComplexV (uInt rownr, Complex* dataPtr);
166  void getDComplexV (uInt rownr, DComplex* dataPtr);
167  // </group>
168 
169  // Put a scalar value into the given row.
170  // The buffer pointed to by dataPtr has to have the correct length
171  // (which is guaranteed by the Scalar/ArrayColumn put function).
172  // <group>
173  void putBoolV (uInt rownr, const Bool* dataPtr);
174  void putuCharV (uInt rownr, const uChar* dataPtr);
175  void putShortV (uInt rownr, const Short* dataPtr);
176  void putuShortV (uInt rownr, const uShort* dataPtr);
177  void putIntV (uInt rownr, const Int* dataPtr);
178  void putuIntV (uInt rownr, const uInt* dataPtr);
179  void putfloatV (uInt rownr, const float* dataPtr);
180  void putdoubleV (uInt rownr, const double* dataPtr);
181  void putComplexV (uInt rownr, const Complex* dataPtr);
182  void putDComplexV (uInt rownr, const DComplex* dataPtr);
183  // </group>
184 
185  // Get the array value in the given row.
186  // The array pointed to by dataPtr has to have the correct length
187  // (which is guaranteed by the ArrayColumn get function).
188  // The default implementation thrown an "invalid operation exception".
189  // <group>
190  void getArrayBoolV (uInt rownr, Array<Bool>* dataPtr);
191  void getArrayuCharV (uInt rownr, Array<uChar>* dataPtr);
192  void getArrayShortV (uInt rownr, Array<Short>* dataPtr);
193  void getArrayuShortV (uInt rownr, Array<uShort>* dataPtr);
194  void getArrayIntV (uInt rownr, Array<Int>* dataPtr);
195  void getArrayuIntV (uInt rownr, Array<uInt>* dataPtr);
196  void getArrayfloatV (uInt rownr, Array<float>* dataPtr);
197  void getArraydoubleV (uInt rownr, Array<double>* dataPtr);
198  void getArrayComplexV (uInt rownr, Array<Complex>* dataPtr);
199  void getArrayDComplexV (uInt rownr, Array<DComplex>* dataPtr);
200  // </group>
201 
202  // Put the array value into the given row.
203  // The buffer pointed to by dataPtr has to have the correct length
204  // (which is guaranteed by the ArrayColumn put function).
205  // The default implementation thrown an "invalid operation exception".
206  // <group>
207  void putArrayBoolV (uInt rownr, const Array<Bool>* dataPtr);
208  void putArrayuCharV (uInt rownr, const Array<uChar>* dataPtr);
209  void putArrayShortV (uInt rownr, const Array<Short>* dataPtr);
210  void putArrayuShortV (uInt rownr, const Array<uShort>* dataPtr);
211  void putArrayIntV (uInt rownr, const Array<Int>* dataPtr);
212  void putArrayuIntV (uInt rownr, const Array<uInt>* dataPtr);
213  void putArrayfloatV (uInt rownr, const Array<float>* dataPtr);
214  void putArraydoubleV (uInt rownr, const Array<double>* dataPtr);
215  void putArrayComplexV (uInt rownr, const Array<Complex>* dataPtr);
216  void putArrayDComplexV (uInt rownr, const Array<DComplex>* dataPtr);
217  // </group>
218 
219  void getSliceBoolV (uInt rownr, const Slicer& slicer,
220  Array<Bool>* dataPtr);
221  void getSliceuCharV (uInt rownr, const Slicer& slicer,
222  Array<uChar>* dataPtr);
223  void getSliceShortV (uInt rownr, const Slicer& slicer,
224  Array<Short>* dataPtr);
225  void getSliceuShortV (uInt rownr, const Slicer& slicer,
226  Array<uShort>* dataPtr);
227  void getSliceIntV (uInt rownr, const Slicer& slicer,
228  Array<Int>* dataPtr);
229  void getSliceuIntV (uInt rownr, const Slicer& slicer,
230  Array<uInt>* dataPtr);
231  void getSlicefloatV (uInt rownr, const Slicer& slicer,
232  Array<float>* dataPtr);
233  void getSlicedoubleV (uInt rownr, const Slicer& slicer,
234  Array<double>* dataPtr);
235  void getSliceComplexV (uInt rownr, const Slicer& slicer,
236  Array<Complex>* dataPtr);
237  void getSliceDComplexV (uInt rownr, const Slicer& slicer,
238  Array<DComplex>* dataPtr);
239 
240  void putSliceBoolV (uInt rownr, const Slicer& slicer,
241  const Array<Bool>* dataPtr);
242  void putSliceuCharV (uInt rownr, const Slicer& slicer,
243  const Array<uChar>* dataPtr);
244  void putSliceShortV (uInt rownr, const Slicer& slicer,
245  const Array<Short>* dataPtr);
246  void putSliceuShortV (uInt rownr, const Slicer& slicer,
247  const Array<uShort>* dataPtr);
248  void putSliceIntV (uInt rownr, const Slicer& slicer,
249  const Array<Int>* dataPtr);
250  void putSliceuIntV (uInt rownr, const Slicer& slicer,
251  const Array<uInt>* dataPtr);
252  void putSlicefloatV (uInt rownr, const Slicer& slicer,
253  const Array<float>* dataPtr);
254  void putSlicedoubleV (uInt rownr, const Slicer& slicer,
255  const Array<double>* dataPtr);
256  void putSliceComplexV (uInt rownr, const Slicer& slicer,
257  const Array<Complex>* dataPtr);
258  void putSliceDComplexV (uInt rownr, const Slicer& slicer,
259  const Array<DComplex>* dataPtr);
260 
265  void getScalarColumnIntV (Vector<Int>* arr);
271 
272  void putScalarColumnBoolV (const Vector<Bool>* arr);
273  void putScalarColumnuCharV (const Vector<uChar>* arr);
274  void putScalarColumnShortV (const Vector<Short>* arr);
275  void putScalarColumnuShortV (const Vector<uShort>* arr);
276  void putScalarColumnIntV (const Vector<Int>* arr);
277  void putScalarColumnuIntV (const Vector<uInt>* arr);
278  void putScalarColumnfloatV (const Vector<float>* arr);
279  void putScalarColumndoubleV (const Vector<double>* arr);
280  void putScalarColumnComplexV (const Vector<Complex>* arr);
281  void putScalarColumnDComplexV (const Vector<DComplex>* arr);
282 
283  // Get the scalar values in some cells of the column.
284  // The buffer pointed to by dataPtr has to have the correct length.
285  // (which is guaranteed by the ScalarColumn getColumnCells function).
286  // The default implementation loops through all rows.
287  // <group>
288  virtual void getScalarColumnCellsBoolV (const RefRows& rownrs,
289  Vector<Bool>* dataPtr);
290  virtual void getScalarColumnCellsuCharV (const RefRows& rownrs,
291  Vector<uChar>* dataPtr);
292  virtual void getScalarColumnCellsShortV (const RefRows& rownrs,
293  Vector<Short>* dataPtr);
294  virtual void getScalarColumnCellsuShortV (const RefRows& rownrs,
295  Vector<uShort>* dataPtr);
296  virtual void getScalarColumnCellsIntV (const RefRows& rownrs,
297  Vector<Int>* dataPtr);
298  virtual void getScalarColumnCellsuIntV (const RefRows& rownrs,
299  Vector<uInt>* dataPtr);
300  virtual void getScalarColumnCellsfloatV (const RefRows& rownrs,
301  Vector<float>* dataPtr);
302  virtual void getScalarColumnCellsdoubleV (const RefRows& rownrs,
303  Vector<double>* dataPtr);
304  virtual void getScalarColumnCellsComplexV (const RefRows& rownrs,
305  Vector<Complex>* dataPtr);
306  virtual void getScalarColumnCellsDComplexV (const RefRows& rownrs,
307  Vector<DComplex>* dataPtr);
308  // </group>
309 
310  // Put the scalar values into some cells of the column.
311  // The buffer pointed to by dataPtr has to have the correct length.
312  // (which is guaranteed by the ScalarColumn putColumnCells function).
313  // The default implementation loops through all rows.
314  // <group>
315  virtual void putScalarColumnCellsBoolV (const RefRows& rownrs,
316  const Vector<Bool>* dataPtr);
317  virtual void putScalarColumnCellsuCharV (const RefRows& rownrs,
318  const Vector<uChar>* dataPtr);
319  virtual void putScalarColumnCellsShortV (const RefRows& rownrs,
320  const Vector<Short>* dataPtr);
321  virtual void putScalarColumnCellsuShortV (const RefRows& rownrs,
322  const Vector<uShort>* dataPtr);
323  virtual void putScalarColumnCellsIntV (const RefRows& rownrs,
324  const Vector<Int>* dataPtr);
325  virtual void putScalarColumnCellsuIntV (const RefRows& rownrs,
326  const Vector<uInt>* dataPtr);
327  virtual void putScalarColumnCellsfloatV (const RefRows& rownrs,
328  const Vector<float>* dataPtr);
329  virtual void putScalarColumnCellsdoubleV (const RefRows& rownrs,
330  const Vector<double>* dataPtr);
331  virtual void putScalarColumnCellsComplexV (const RefRows& rownrs,
332  const Vector<Complex>* dataPtr);
333  virtual void putScalarColumnCellsDComplexV (const RefRows& rownrs,
334  const Vector<DComplex>* dataPtr);
335  // </group>
336 
337  void getArrayColumnBoolV (Array<Bool>* arr);
341  void getArrayColumnIntV (Array<Int>* arr);
342  void getArrayColumnuIntV (Array<uInt>* arr);
347 
348  void putArrayColumnBoolV (const Array<Bool>* arr);
349  void putArrayColumnuCharV (const Array<uChar>* arr);
350  void putArrayColumnShortV (const Array<Short>* arr);
351  void putArrayColumnuShortV (const Array<uShort>* arr);
352  void putArrayColumnIntV (const Array<Int>* arr);
353  void putArrayColumnuIntV (const Array<uInt>* arr);
354  void putArrayColumnfloatV (const Array<float>* arr);
355  void putArrayColumndoubleV (const Array<double>* arr);
356  void putArrayColumnComplexV (const Array<Complex>* arr);
357  void putArrayColumnDComplexV (const Array<DComplex>* arr);
358 
359  // Get the array values in some cells of the column.
360  // The buffer pointed to by dataPtr has to have the correct length.
361  // (which is guaranteed by the ArrayColumn getColumnCells function).
362  // The default implementation throws an "invalid operation exception".
363  // <group>
364  virtual void getArrayColumnCellsBoolV (const RefRows& rownrs,
365  Array<Bool>* dataPtr);
366  virtual void getArrayColumnCellsuCharV (const RefRows& rownrs,
367  Array<uChar>* dataPtr);
368  virtual void getArrayColumnCellsShortV (const RefRows& rownrs,
369  Array<Short>* dataPtr);
370  virtual void getArrayColumnCellsuShortV (const RefRows& rownrs,
371  Array<uShort>* dataPtr);
372  virtual void getArrayColumnCellsIntV (const RefRows& rownrs,
373  Array<Int>* dataPtr);
374  virtual void getArrayColumnCellsuIntV (const RefRows& rownrs,
375  Array<uInt>* dataPtr);
376  virtual void getArrayColumnCellsfloatV (const RefRows& rownrs,
377  Array<float>* dataPtr);
378  virtual void getArrayColumnCellsdoubleV (const RefRows& rownrs,
379  Array<double>* dataPtr);
380  virtual void getArrayColumnCellsComplexV (const RefRows& rownrs,
381  Array<Complex>* dataPtr);
382  virtual void getArrayColumnCellsDComplexV (const RefRows& rownrs,
383  Array<DComplex>* dataPtr);
384  // </group>
385 
386  // Put the array values into some cells of the column.
387  // The buffer pointed to by dataPtr has to have the correct length.
388  // (which is guaranteed by the ArrayColumn putColumnCells function).
389  // The default implementation throws an "invalid operation exception".
390  // <group>
391  virtual void putArrayColumnCellsBoolV (const RefRows& rownrs,
392  const Array<Bool>* dataPtr);
393  virtual void putArrayColumnCellsuCharV (const RefRows& rownrs,
394  const Array<uChar>* dataPtr);
395  virtual void putArrayColumnCellsShortV (const RefRows& rownrs,
396  const Array<Short>* dataPtr);
397  virtual void putArrayColumnCellsuShortV (const RefRows& rownrs,
398  const Array<uShort>* dataPtr);
399  virtual void putArrayColumnCellsIntV (const RefRows& rownrs,
400  const Array<Int>* dataPtr);
401  virtual void putArrayColumnCellsuIntV (const RefRows& rownrs,
402  const Array<uInt>* dataPtr);
403  virtual void putArrayColumnCellsfloatV (const RefRows& rownrs,
404  const Array<float>* dataPtr);
405  virtual void putArrayColumnCellsdoubleV (const RefRows& rownrs,
406  const Array<double>* dataPtr);
407  virtual void putArrayColumnCellsComplexV (const RefRows& rownrs,
408  const Array<Complex>* dataPtr);
409  virtual void putArrayColumnCellsDComplexV (const RefRows& rownrs,
410  const Array<DComplex>* dataPtr);
411  // </group>
412 
413  void getColumnSliceBoolV (const Slicer& slicer, Array<Bool>* arr);
414  void getColumnSliceuCharV (const Slicer& slicer, Array<uChar>* arr);
415  void getColumnSliceShortV (const Slicer& slicer, Array<Short>* arr);
416  void getColumnSliceuShortV (const Slicer& slicer, Array<uShort>* arr);
417  void getColumnSliceIntV (const Slicer& slicer, Array<Int>* arr);
418  void getColumnSliceuIntV (const Slicer& slicer, Array<uInt>* arr);
419  void getColumnSlicefloatV (const Slicer& slicer, Array<float>* arr);
420  void getColumnSlicedoubleV (const Slicer& slicer, Array<double>* arr);
421  void getColumnSliceComplexV (const Slicer& slicer, Array<Complex>* arr);
422  void getColumnSliceDComplexV (const Slicer& slicer, Array<DComplex>* arr);
423 
424  void putColumnSliceBoolV (const Slicer& slicer,
425  const Array<Bool>* dataPtr);
426  void putColumnSliceuCharV (const Slicer& slicer,
427  const Array<uChar>* dataPtr);
428  void putColumnSliceShortV (const Slicer& slicer,
429  const Array<Short>* dataPtr);
430  void putColumnSliceuShortV (const Slicer& slicer,
431  const Array<uShort>* dataPtr);
432  void putColumnSliceIntV (const Slicer& slicer,
433  const Array<Int>* dataPtr);
434  void putColumnSliceuIntV (const Slicer& slicer,
435  const Array<uInt>* dataPtr);
436  void putColumnSlicefloatV (const Slicer& slicer,
437  const Array<float>* dataPtr);
438  void putColumnSlicedoubleV (const Slicer& slicer,
439  const Array<double>* dataPtr);
440  void putColumnSliceComplexV (const Slicer& slicer,
441  const Array<Complex>* dataPtr);
442  void putColumnSliceDComplexV (const Slicer& slicer,
443  const Array<DComplex>* dataPtr);
444 
445  // Get the array values in some cells of the column.
446  // The buffer pointed to by dataPtr has to have the correct length.
447  // (which is guaranteed by the ArrayColumn getColumnCells function).
448  // The default implementation throws an "invalid operation exception".
449  // <group>
450  virtual void getColumnSliceCellsBoolV (const RefRows& rownrs,
451  const Slicer& ns,
452  Array<Bool>* dataPtr);
453  virtual void getColumnSliceCellsuCharV (const RefRows& rownrs,
454  const Slicer& ns,
455  Array<uChar>* dataPtr);
456  virtual void getColumnSliceCellsShortV (const RefRows& rownrs,
457  const Slicer& ns,
458  Array<Short>* dataPtr);
459  virtual void getColumnSliceCellsuShortV (const RefRows& rownrs,
460  const Slicer& ns,
461  Array<uShort>* dataPtr);
462  virtual void getColumnSliceCellsIntV (const RefRows& rownrs,
463  const Slicer& ns,
464  Array<Int>* dataPtr);
465  virtual void getColumnSliceCellsuIntV (const RefRows& rownrs,
466  const Slicer& ns,
467  Array<uInt>* dataPtr);
468  virtual void getColumnSliceCellsfloatV (const RefRows& rownrs,
469  const Slicer& ns,
470  Array<float>* dataPtr);
471  virtual void getColumnSliceCellsdoubleV (const RefRows& rownrs,
472  const Slicer& ns,
473  Array<double>* dataPtr);
474  virtual void getColumnSliceCellsComplexV (const RefRows& rownrs,
475  const Slicer& ns,
476  Array<Complex>* dataPtr);
477  virtual void getColumnSliceCellsDComplexV (const RefRows& rownrs,
478  const Slicer& ns,
479  Array<DComplex>* dataPtr);
480  // </group>
481 
482  // Put the array values into some cells of the column.
483  // The buffer pointed to by dataPtr has to have the correct length.
484  // (which is guaranteed by the ArrayColumn putColumnSlice function).
485  // The default implementation throws an "invalid operation exception".
486  // <group>
487  virtual void putColumnSliceCellsBoolV (const RefRows& rownrs,
488  const Slicer& ns,
489  const Array<Bool>* dataPtr);
490  virtual void putColumnSliceCellsuCharV (const RefRows& rownrs,
491  const Slicer& ns,
492  const Array<uChar>* dataPtr);
493  virtual void putColumnSliceCellsShortV (const RefRows& rownrs,
494  const Slicer& ns,
495  const Array<Short>* dataPtr);
496  virtual void putColumnSliceCellsuShortV (const RefRows& rownrs,
497  const Slicer& ns,
498  const Array<uShort>* dataPtr);
499  virtual void putColumnSliceCellsIntV (const RefRows& rownrs,
500  const Slicer& ns,
501  const Array<Int>* dataPtr);
502  virtual void putColumnSliceCellsuIntV (const RefRows& rownrs,
503  const Slicer& ns,
504  const Array<uInt>* dataPtr);
505  virtual void putColumnSliceCellsfloatV (const RefRows& rownrs,
506  const Slicer& ns,
507  const Array<float>* dataPtr);
508  virtual void putColumnSliceCellsdoubleV (const RefRows& rownrs,
509  const Slicer& ns,
510  const Array<double>* dataPtr);
511  virtual void putColumnSliceCellsComplexV (const RefRows& rownrs,
512  const Slicer& ns,
513  const Array<Complex>* dataPtr);
514  virtual void putColumnSliceCellsDComplexV (const RefRows& rownrs,
515  const Slicer& ns,
516  const Array<DComplex>* dataPtr);
517  // </group>
518 
519  // Read the data of the column from a tile.
520  // (I.e. convert from external to local format).
521  void readTile (void* to, const void* from, uInt nrPixels);
522 
523  // Write the data of the column into a tile.
524  // (I.e. convert from local to external format).
525  void writeTile (void* to, const void* from, uInt nrPixels);
526 
527  // Get the function to convert from external to local format
528  // (or vice-versa if <src>writeFlag=True</src>).
530  { return writeFlag ? writeFunc_p : readFunc_p; }
531 
532  // Get nr of elements in a value to convert (usually 1, but 2 for Complex).
533  size_t getNrConvert() const
534  { return convPixelSize_p; }
535 
536  // Does a conversion (byte swap) needs to be done?
538  { return mustConvert_p; }
539 
540 private:
541  // The (canonical) size of a pixel in a tile.
543  // The local size of a pixel.
545  // The multiplication factor for a conversion operation.
546  // This is the pixel size when a memcpy can be used, otherwise it is 1.
548  // Is a conversion necessary?
550  // The column sequence number.
552  // The conversion function needed when reading.
554  // The conversion function needed when writing.
556 
557 
558  // Forbid copy constructor.
559  TSMDataColumn (const TSMDataColumn&);
560 
561  // Forbid assignment.
563 
564  // Read or write a data cell in the cube.
565  // A cell can contain a scalar or an array (depending on the
566  // column definition).
567  void accessCell (uInt rownr,
568  const void* dataPtr, Bool writeFlag);
569 
570  // Read or write a slice of a data cell in the cube.
571  void accessCellSlice (uInt rownr, const Slicer& ns,
572  const void* dataPtr, Bool writeFlag);
573 
574  // Read or write an entire column.
575  // This can only be done if one hypercube is used.
576  void accessColumn (const void* dataPtr, Bool writeFlag);
577 
578  // Read or write a slice from the entire column.
579  // This can only be done if one hypercube is used.
580  void accessColumnSlice (const Slicer& ns,
581  const void* dataPtr, Bool writeFlag);
582 
583  // Read or write some cells in a column.
584  // It tries to optimize by looking for regular row strides.
585  void accessColumnCells (const RefRows& rownrs, const IPosition& shape,
586  const void* dataPtr, Bool writeFlag);
587 
588  // Read or write some cells in a column.
589  // It tries to optimize by looking for regular row strides.
590  void accessColumnSliceCells (const RefRows& rownrs, const Slicer& ns,
591  const IPosition& shape,
592  const void* dataPtr, Bool writeFlag);
593 
594  // Read or write the full cells given by start,end,incr.
595  void accessFullCells (TSMCube* hypercube,
596  char* dataPtr, Bool writeFlag,
597  const IPosition& start,
598  const IPosition& end,
599  const IPosition& incr);
600 
601  // Read or write the sliced cells given by start,end,incr.
602  void accessSlicedCells (TSMCube* hypercube,
603  char* dataPtr, Bool writeFlag,
604  const IPosition& start,
605  const IPosition& end,
606  const IPosition& incr);
607 };
608 
609 
611 {
612  return tilePixelSize_p;
613 }
615 {
616  return localPixelSize_p;
617 }
619 {
620  colnr_p = colnr;
621 }
622 inline void TSMDataColumn::readTile (void* to, const void* from,
623  uInt nrPixels)
624 {
625  readFunc_p (to, from, nrPixels * convPixelSize_p);
626 }
627 inline void TSMDataColumn::writeTile (void* to, const void* from,
628  uInt nrPixels)
629 {
630  writeFunc_p (to, from, nrPixels * convPixelSize_p);
631 }
632 
633 
634 
635 } //# NAMESPACE CASACORE - END
636 
637 #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:47
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:44
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:45
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.
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:39
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:275
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:48
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:46
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.