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.
120 
121  // It can handle access to an array column if there is one hypercube.
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.
129 
130  // Changing array shapes for non-FixedShape columns when the
131  // parent tiled storage manager can handle it.
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?
149 
150  // Get the shape of the item in the given row.
152 
153  // Get the tile shape of the item in the given row.
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 getInt64V (uInt rownr, Int64* dataPtr);
167  void getfloatV (uInt rownr, float* dataPtr);
168  void getdoubleV (uInt rownr, double* dataPtr);
169  void getComplexV (uInt rownr, Complex* dataPtr);
170  void getDComplexV (uInt rownr, DComplex* dataPtr);
171  // </group>
172 
173  // Put a scalar value into the given row.
174  // The buffer pointed to by dataPtr has to have the correct length
175  // (which is guaranteed by the Scalar/ArrayColumn put function).
176  // <group>
177  void putBoolV (uInt rownr, const Bool* dataPtr);
178  void putuCharV (uInt rownr, const uChar* dataPtr);
179  void putShortV (uInt rownr, const Short* dataPtr);
180  void putuShortV (uInt rownr, const uShort* dataPtr);
181  void putIntV (uInt rownr, const Int* dataPtr);
182  void putuIntV (uInt rownr, const uInt* dataPtr);
183  void putInt64V (uInt rownr, const Int64* dataPtr);
184  void putfloatV (uInt rownr, const float* dataPtr);
185  void putdoubleV (uInt rownr, const double* dataPtr);
186  void putComplexV (uInt rownr, const Complex* dataPtr);
187  void putDComplexV (uInt rownr, const DComplex* dataPtr);
188  // </group>
189 
190  // Get the array value in the given row.
191  // The array pointed to by dataPtr has to have the correct length
192  // (which is guaranteed by the ArrayColumn get function).
193  // The default implementation thrown an "invalid operation exception".
194  // <group>
195  void getArrayBoolV (uInt rownr, Array<Bool>* dataPtr);
196  void getArrayuCharV (uInt rownr, Array<uChar>* dataPtr);
197  void getArrayShortV (uInt rownr, Array<Short>* dataPtr);
198  void getArrayuShortV (uInt rownr, Array<uShort>* dataPtr);
199  void getArrayIntV (uInt rownr, Array<Int>* dataPtr);
200  void getArrayuIntV (uInt rownr, Array<uInt>* dataPtr);
201  void getArrayInt64V (uInt rownr, Array<Int64>* dataPtr);
202  void getArrayfloatV (uInt rownr, Array<float>* dataPtr);
203  void getArraydoubleV (uInt rownr, Array<double>* dataPtr);
204  void getArrayComplexV (uInt rownr, Array<Complex>* dataPtr);
205  void getArrayDComplexV (uInt rownr, Array<DComplex>* dataPtr);
206  // </group>
207 
208  // Put the array value into the given row.
209  // The buffer pointed to by dataPtr has to have the correct length
210  // (which is guaranteed by the ArrayColumn put function).
211  // The default implementation thrown an "invalid operation exception".
212  // <group>
213  void putArrayBoolV (uInt rownr, const Array<Bool>* dataPtr);
214  void putArrayuCharV (uInt rownr, const Array<uChar>* dataPtr);
215  void putArrayShortV (uInt rownr, const Array<Short>* dataPtr);
216  void putArrayuShortV (uInt rownr, const Array<uShort>* dataPtr);
217  void putArrayIntV (uInt rownr, const Array<Int>* dataPtr);
218  void putArrayuIntV (uInt rownr, const Array<uInt>* dataPtr);
219  void putArrayInt64V (uInt rownr, const Array<Int64>* dataPtr);
220  void putArrayfloatV (uInt rownr, const Array<float>* dataPtr);
221  void putArraydoubleV (uInt rownr, const Array<double>* dataPtr);
222  void putArrayComplexV (uInt rownr, const Array<Complex>* dataPtr);
223  void putArrayDComplexV (uInt rownr, const Array<DComplex>* dataPtr);
224  // </group>
225 
226  void getSliceBoolV (uInt rownr, const Slicer& slicer,
227  Array<Bool>* dataPtr);
228  void getSliceuCharV (uInt rownr, const Slicer& slicer,
229  Array<uChar>* dataPtr);
230  void getSliceShortV (uInt rownr, const Slicer& slicer,
231  Array<Short>* dataPtr);
232  void getSliceuShortV (uInt rownr, const Slicer& slicer,
233  Array<uShort>* dataPtr);
234  void getSliceIntV (uInt rownr, const Slicer& slicer,
235  Array<Int>* dataPtr);
236  void getSliceuIntV (uInt rownr, const Slicer& slicer,
237  Array<uInt>* dataPtr);
238  void getSliceInt64V (uInt rownr, const Slicer& slicer,
239  Array<Int64>* dataPtr);
240  void getSlicefloatV (uInt rownr, const Slicer& slicer,
241  Array<float>* dataPtr);
242  void getSlicedoubleV (uInt rownr, const Slicer& slicer,
243  Array<double>* dataPtr);
244  void getSliceComplexV (uInt rownr, const Slicer& slicer,
245  Array<Complex>* dataPtr);
246  void getSliceDComplexV (uInt rownr, const Slicer& slicer,
247  Array<DComplex>* dataPtr);
248 
249  void putSliceBoolV (uInt rownr, const Slicer& slicer,
250  const Array<Bool>* dataPtr);
251  void putSliceuCharV (uInt rownr, const Slicer& slicer,
252  const Array<uChar>* dataPtr);
253  void putSliceShortV (uInt rownr, const Slicer& slicer,
254  const Array<Short>* dataPtr);
255  void putSliceuShortV (uInt rownr, const Slicer& slicer,
256  const Array<uShort>* dataPtr);
257  void putSliceIntV (uInt rownr, const Slicer& slicer,
258  const Array<Int>* dataPtr);
259  void putSliceuIntV (uInt rownr, const Slicer& slicer,
260  const Array<uInt>* dataPtr);
261  void putSliceInt64V (uInt rownr, const Slicer& slicer,
262  const Array<Int64>* dataPtr);
263  void putSlicefloatV (uInt rownr, const Slicer& slicer,
264  const Array<float>* dataPtr);
265  void putSlicedoubleV (uInt rownr, const Slicer& slicer,
266  const Array<double>* dataPtr);
267  void putSliceComplexV (uInt rownr, const Slicer& slicer,
268  const Array<Complex>* dataPtr);
269  void putSliceDComplexV (uInt rownr, const Slicer& slicer,
270  const Array<DComplex>* dataPtr);
271 
283 
288  void putScalarColumnIntV (const Vector<Int>* arr);
295 
296  // Get the scalar values in some cells of the column.
297  // The buffer pointed to by dataPtr has to have the correct length.
298  // (which is guaranteed by the ScalarColumn getColumnCells function).
299  // The default implementation loops through all rows.
300  // <group>
301  virtual void getScalarColumnCellsBoolV (const RefRows& rownrs,
302  Vector<Bool>* dataPtr);
303  virtual void getScalarColumnCellsuCharV (const RefRows& rownrs,
304  Vector<uChar>* dataPtr);
305  virtual void getScalarColumnCellsShortV (const RefRows& rownrs,
306  Vector<Short>* dataPtr);
307  virtual void getScalarColumnCellsuShortV (const RefRows& rownrs,
308  Vector<uShort>* dataPtr);
309  virtual void getScalarColumnCellsIntV (const RefRows& rownrs,
310  Vector<Int>* dataPtr);
311  virtual void getScalarColumnCellsuIntV (const RefRows& rownrs,
312  Vector<uInt>* dataPtr);
313  virtual void getScalarColumnCellsInt64V (const RefRows& rownrs,
314  Vector<Int64>* dataPtr);
315  virtual void getScalarColumnCellsfloatV (const RefRows& rownrs,
316  Vector<float>* dataPtr);
317  virtual void getScalarColumnCellsdoubleV (const RefRows& rownrs,
318  Vector<double>* dataPtr);
319  virtual void getScalarColumnCellsComplexV (const RefRows& rownrs,
320  Vector<Complex>* dataPtr);
321  virtual void getScalarColumnCellsDComplexV (const RefRows& rownrs,
322  Vector<DComplex>* dataPtr);
323  // </group>
324 
325  // Put the scalar values into some cells of the column.
326  // The buffer pointed to by dataPtr has to have the correct length.
327  // (which is guaranteed by the ScalarColumn putColumnCells function).
328  // The default implementation loops through all rows.
329  // <group>
330  virtual void putScalarColumnCellsBoolV (const RefRows& rownrs,
331  const Vector<Bool>* dataPtr);
332  virtual void putScalarColumnCellsuCharV (const RefRows& rownrs,
333  const Vector<uChar>* dataPtr);
334  virtual void putScalarColumnCellsShortV (const RefRows& rownrs,
335  const Vector<Short>* dataPtr);
336  virtual void putScalarColumnCellsuShortV (const RefRows& rownrs,
337  const Vector<uShort>* dataPtr);
338  virtual void putScalarColumnCellsIntV (const RefRows& rownrs,
339  const Vector<Int>* dataPtr);
340  virtual void putScalarColumnCellsuIntV (const RefRows& rownrs,
341  const Vector<uInt>* dataPtr);
342  virtual void putScalarColumnCellsInt64V (const RefRows& rownrs,
343  const Vector<Int64>* dataPtr);
344  virtual void putScalarColumnCellsfloatV (const RefRows& rownrs,
345  const Vector<float>* dataPtr);
346  virtual void putScalarColumnCellsdoubleV (const RefRows& rownrs,
347  const Vector<double>* dataPtr);
348  virtual void putScalarColumnCellsComplexV (const RefRows& rownrs,
349  const Vector<Complex>* dataPtr);
350  virtual void putScalarColumnCellsDComplexV (const RefRows& rownrs,
351  const Vector<DComplex>* dataPtr);
352  // </group>
353 
365 
366  void putArrayColumnBoolV (const Array<Bool>* arr);
370  void putArrayColumnIntV (const Array<Int>* arr);
371  void putArrayColumnuIntV (const Array<uInt>* arr);
377 
378  // Get the array values in some cells of the column.
379  // The buffer pointed to by dataPtr has to have the correct length.
380  // (which is guaranteed by the ArrayColumn getColumnCells function).
381  // The default implementation throws an "invalid operation exception".
382  // <group>
383  virtual void getArrayColumnCellsBoolV (const RefRows& rownrs,
384  Array<Bool>* dataPtr);
385  virtual void getArrayColumnCellsuCharV (const RefRows& rownrs,
386  Array<uChar>* dataPtr);
387  virtual void getArrayColumnCellsShortV (const RefRows& rownrs,
388  Array<Short>* dataPtr);
389  virtual void getArrayColumnCellsuShortV (const RefRows& rownrs,
390  Array<uShort>* dataPtr);
391  virtual void getArrayColumnCellsIntV (const RefRows& rownrs,
392  Array<Int>* dataPtr);
393  virtual void getArrayColumnCellsuIntV (const RefRows& rownrs,
394  Array<uInt>* dataPtr);
395  virtual void getArrayColumnCellsInt64V (const RefRows& rownrs,
396  Array<Int64>* dataPtr);
397  virtual void getArrayColumnCellsfloatV (const RefRows& rownrs,
398  Array<float>* dataPtr);
399  virtual void getArrayColumnCellsdoubleV (const RefRows& rownrs,
400  Array<double>* dataPtr);
401  virtual void getArrayColumnCellsComplexV (const RefRows& rownrs,
402  Array<Complex>* dataPtr);
403  virtual void getArrayColumnCellsDComplexV (const RefRows& rownrs,
404  Array<DComplex>* dataPtr);
405  // </group>
406 
407  // Put the array values into some cells of the column.
408  // The buffer pointed to by dataPtr has to have the correct length.
409  // (which is guaranteed by the ArrayColumn putColumnCells function).
410  // The default implementation throws an "invalid operation exception".
411  // <group>
412  virtual void putArrayColumnCellsBoolV (const RefRows& rownrs,
413  const Array<Bool>* dataPtr);
414  virtual void putArrayColumnCellsuCharV (const RefRows& rownrs,
415  const Array<uChar>* dataPtr);
416  virtual void putArrayColumnCellsShortV (const RefRows& rownrs,
417  const Array<Short>* dataPtr);
418  virtual void putArrayColumnCellsuShortV (const RefRows& rownrs,
419  const Array<uShort>* dataPtr);
420  virtual void putArrayColumnCellsIntV (const RefRows& rownrs,
421  const Array<Int>* dataPtr);
422  virtual void putArrayColumnCellsuIntV (const RefRows& rownrs,
423  const Array<uInt>* dataPtr);
424  virtual void putArrayColumnCellsInt64V (const RefRows& rownrs,
425  const Array<Int64>* dataPtr);
426  virtual void putArrayColumnCellsfloatV (const RefRows& rownrs,
427  const Array<float>* dataPtr);
428  virtual void putArrayColumnCellsdoubleV (const RefRows& rownrs,
429  const Array<double>* dataPtr);
430  virtual void putArrayColumnCellsComplexV (const RefRows& rownrs,
431  const Array<Complex>* dataPtr);
432  virtual void putArrayColumnCellsDComplexV (const RefRows& rownrs,
433  const Array<DComplex>* dataPtr);
434  // </group>
435 
436  void getColumnSliceBoolV (const Slicer& slicer, Array<Bool>* arr);
437  void getColumnSliceuCharV (const Slicer& slicer, Array<uChar>* arr);
438  void getColumnSliceShortV (const Slicer& slicer, Array<Short>* arr);
439  void getColumnSliceuShortV (const Slicer& slicer, Array<uShort>* arr);
440  void getColumnSliceIntV (const Slicer& slicer, Array<Int>* arr);
441  void getColumnSliceuIntV (const Slicer& slicer, Array<uInt>* arr);
442  void getColumnSliceInt64V (const Slicer& slicer, Array<Int64>* arr);
443  void getColumnSlicefloatV (const Slicer& slicer, Array<float>* arr);
444  void getColumnSlicedoubleV (const Slicer& slicer, Array<double>* arr);
445  void getColumnSliceComplexV (const Slicer& slicer, Array<Complex>* arr);
446  void getColumnSliceDComplexV (const Slicer& slicer, Array<DComplex>* arr);
447 
448  void putColumnSliceBoolV (const Slicer& slicer,
449  const Array<Bool>* dataPtr);
450  void putColumnSliceuCharV (const Slicer& slicer,
451  const Array<uChar>* dataPtr);
452  void putColumnSliceShortV (const Slicer& slicer,
453  const Array<Short>* dataPtr);
454  void putColumnSliceuShortV (const Slicer& slicer,
455  const Array<uShort>* dataPtr);
456  void putColumnSliceIntV (const Slicer& slicer,
457  const Array<Int>* dataPtr);
458  void putColumnSliceuIntV (const Slicer& slicer,
459  const Array<uInt>* dataPtr);
460  void putColumnSliceInt64V (const Slicer& slicer,
461  const Array<Int64>* dataPtr);
462  void putColumnSlicefloatV (const Slicer& slicer,
463  const Array<float>* dataPtr);
464  void putColumnSlicedoubleV (const Slicer& slicer,
465  const Array<double>* dataPtr);
466  void putColumnSliceComplexV (const Slicer& slicer,
467  const Array<Complex>* dataPtr);
468  void putColumnSliceDComplexV (const Slicer& slicer,
469  const Array<DComplex>* dataPtr);
470 
471  // Get the array values in some cells of the column.
472  // The buffer pointed to by dataPtr has to have the correct length.
473  // (which is guaranteed by the ArrayColumn getColumnCells function).
474  // The default implementation throws an "invalid operation exception".
475  // <group>
476  virtual void getColumnSliceCellsBoolV (const RefRows& rownrs,
477  const Slicer& ns,
478  Array<Bool>* dataPtr);
479  virtual void getColumnSliceCellsuCharV (const RefRows& rownrs,
480  const Slicer& ns,
481  Array<uChar>* dataPtr);
482  virtual void getColumnSliceCellsShortV (const RefRows& rownrs,
483  const Slicer& ns,
484  Array<Short>* dataPtr);
485  virtual void getColumnSliceCellsuShortV (const RefRows& rownrs,
486  const Slicer& ns,
487  Array<uShort>* dataPtr);
488  virtual void getColumnSliceCellsIntV (const RefRows& rownrs,
489  const Slicer& ns,
490  Array<Int>* dataPtr);
491  virtual void getColumnSliceCellsuIntV (const RefRows& rownrs,
492  const Slicer& ns,
493  Array<uInt>* dataPtr);
494  virtual void getColumnSliceCellsInt64V (const RefRows& rownrs,
495  const Slicer& ns,
496  Array<Int64>* dataPtr);
497  virtual void getColumnSliceCellsfloatV (const RefRows& rownrs,
498  const Slicer& ns,
499  Array<float>* dataPtr);
500  virtual void getColumnSliceCellsdoubleV (const RefRows& rownrs,
501  const Slicer& ns,
502  Array<double>* dataPtr);
503  virtual void getColumnSliceCellsComplexV (const RefRows& rownrs,
504  const Slicer& ns,
505  Array<Complex>* dataPtr);
506  virtual void getColumnSliceCellsDComplexV (const RefRows& rownrs,
507  const Slicer& ns,
508  Array<DComplex>* dataPtr);
509  // </group>
510 
511  // Put the array values into some cells of the column.
512  // The buffer pointed to by dataPtr has to have the correct length.
513  // (which is guaranteed by the ArrayColumn putColumnSlice function).
514  // The default implementation throws an "invalid operation exception".
515  // <group>
516  virtual void putColumnSliceCellsBoolV (const RefRows& rownrs,
517  const Slicer& ns,
518  const Array<Bool>* dataPtr);
519  virtual void putColumnSliceCellsuCharV (const RefRows& rownrs,
520  const Slicer& ns,
521  const Array<uChar>* dataPtr);
522  virtual void putColumnSliceCellsShortV (const RefRows& rownrs,
523  const Slicer& ns,
524  const Array<Short>* dataPtr);
525  virtual void putColumnSliceCellsuShortV (const RefRows& rownrs,
526  const Slicer& ns,
527  const Array<uShort>* dataPtr);
528  virtual void putColumnSliceCellsIntV (const RefRows& rownrs,
529  const Slicer& ns,
530  const Array<Int>* dataPtr);
531  virtual void putColumnSliceCellsuIntV (const RefRows& rownrs,
532  const Slicer& ns,
533  const Array<uInt>* dataPtr);
534  virtual void putColumnSliceCellsInt64V (const RefRows& rownrs,
535  const Slicer& ns,
536  const Array<Int64>* dataPtr);
537  virtual void putColumnSliceCellsfloatV (const RefRows& rownrs,
538  const Slicer& ns,
539  const Array<float>* dataPtr);
540  virtual void putColumnSliceCellsdoubleV (const RefRows& rownrs,
541  const Slicer& ns,
542  const Array<double>* dataPtr);
543  virtual void putColumnSliceCellsComplexV (const RefRows& rownrs,
544  const Slicer& ns,
545  const Array<Complex>* dataPtr);
546  virtual void putColumnSliceCellsDComplexV (const RefRows& rownrs,
547  const Slicer& ns,
548  const Array<DComplex>* dataPtr);
549  // </group>
550 
551  // Read the data of the column from a tile.
552  // (I.e. convert from external to local format).
553  void readTile (void* to, const void* from, uInt nrPixels);
554 
555  // Write the data of the column into a tile.
556  // (I.e. convert from local to external format).
557  void writeTile (void* to, const void* from, uInt nrPixels);
558 
559  // Get the function to convert from external to local format
560  // (or vice-versa if <src>writeFlag=True</src>).
562  { return writeFlag ? writeFunc_p : readFunc_p; }
563 
564  // Get nr of elements in a value to convert (usually 1, but 2 for Complex).
565  size_t getNrConvert() const
566  { return convPixelSize_p; }
567 
568  // Does a conversion (byte swap) needs to be done?
570  { return mustConvert_p; }
571 
572 private:
573  // The (canonical) size of a pixel in a tile.
575  // The local size of a pixel.
577  // The multiplication factor for a conversion operation.
578  // This is the pixel size when a memcpy can be used, otherwise it is 1.
580  // Is a conversion necessary?
582  // The column sequence number.
584  // The conversion function needed when reading.
586  // The conversion function needed when writing.
588 
589 
590  // Forbid copy constructor.
592 
593  // Forbid assignment.
595 
596  // Read or write a data cell in the cube.
597  // A cell can contain a scalar or an array (depending on the
598  // column definition).
599  void accessCell (uInt rownr,
600  const void* dataPtr, Bool writeFlag);
601 
602  // Read or write a slice of a data cell in the cube.
603  void accessCellSlice (uInt rownr, const Slicer& ns,
604  const void* dataPtr, Bool writeFlag);
605 
606  // Read or write an entire column.
607  // This can only be done if one hypercube is used.
608  void accessColumn (const void* dataPtr, Bool writeFlag);
609 
610  // Read or write a slice from the entire column.
611  // This can only be done if one hypercube is used.
612  void accessColumnSlice (const Slicer& ns,
613  const void* dataPtr, Bool writeFlag);
614 
615  // Read or write some cells in a column.
616  // It tries to optimize by looking for regular row strides.
617  void accessColumnCells (const RefRows& rownrs, const IPosition& shape,
618  const void* dataPtr, Bool writeFlag);
619 
620  // Read or write some cells in a column.
621  // It tries to optimize by looking for regular row strides.
622  void accessColumnSliceCells (const RefRows& rownrs, const Slicer& ns,
623  const IPosition& shape,
624  const void* dataPtr, Bool writeFlag);
625 
626  // Read or write the full cells given by start,end,incr.
627  void accessFullCells (TSMCube* hypercube,
628  char* dataPtr, Bool writeFlag,
629  const IPosition& start,
630  const IPosition& end,
631  const IPosition& incr);
632 
633  // Read or write the sliced cells given by start,end,incr.
634  void accessSlicedCells (TSMCube* hypercube,
635  char* dataPtr, Bool writeFlag,
636  const IPosition& start,
637  const IPosition& end,
638  const IPosition& incr);
639 };
640 
641 
643 {
644  return tilePixelSize_p;
645 }
647 {
648  return localPixelSize_p;
649 }
651 {
652  colnr_p = colnr;
653 }
654 inline void TSMDataColumn::readTile (void* to, const void* from,
655  uInt nrPixels)
656 {
657  readFunc_p (to, from, nrPixels * convPixelSize_p);
658 }
659 inline void TSMDataColumn::writeTile (void* to, const void* from,
660  uInt nrPixels)
661 {
662  writeFunc_p (to, from, nrPixels * convPixelSize_p);
663 }
664 
665 
666 
667 } //# NAMESPACE CASACORE - END
668 
669 #endif
casacore::TSMDataColumn::putScalarColumnDComplexV
void putScalarColumnDComplexV(const Vector< DComplex > *arr)
casacore::TSMDataColumn::canAccessScalarColumn
Bool canAccessScalarColumn(Bool &reask) const
It can handle access to a scalar column if there is one hypercube.
casacore::TSMDataColumn::getColumnSlicefloatV
void getColumnSlicefloatV(const Slicer &slicer, Array< float > *arr)
casacore::TSMDataColumn::putInt64V
void putInt64V(uInt rownr, const Int64 *dataPtr)
casacore::Slicer
Definition: Slicer.h:290
casacore::TSMDataColumn::TSMDataColumn
TSMDataColumn(const TSMColumn &column)
Create a data column from the given column.
casacore::TSMDataColumn::getColumnSliceBoolV
void getColumnSliceBoolV(const Slicer &slicer, Array< Bool > *arr)
Get the array values in the entire column.
casacore::TSMDataColumn::putArrayColumnCellsdoubleV
virtual void putArrayColumnCellsdoubleV(const RefRows &rownrs, const Array< double > *dataPtr)
casacore::TSMDataColumn::operator=
TSMDataColumn & operator=(const TSMDataColumn &)
Forbid assignment.
casacore::TSMDataColumn::putScalarColumnCellsDComplexV
virtual void putScalarColumnCellsDComplexV(const RefRows &rownrs, const Vector< DComplex > *dataPtr)
casacore::TSMDataColumn::getSliceuShortV
void getSliceuShortV(uInt rownr, const Slicer &slicer, Array< uShort > *dataPtr)
casacore::TSMDataColumn::getArrayColumnCellsDComplexV
virtual void getArrayColumnCellsDComplexV(const RefRows &rownrs, Array< DComplex > *dataPtr)
casacore::IPosition
Definition: IPosition.h:120
casacore::TSMDataColumn::getSliceIntV
void getSliceIntV(uInt rownr, const Slicer &slicer, Array< Int > *dataPtr)
casacore::TSMDataColumn::getArrayColumnShortV
void getArrayColumnShortV(Array< Short > *arr)
casacore::TSMDataColumn::getBoolV
void getBoolV(uInt rownr, Bool *dataPtr)
Get a scalar value in the given row.
casacore::TSMDataColumn::getSliceBoolV
void getSliceBoolV(uInt rownr, const Slicer &slicer, Array< Bool > *dataPtr)
Get the array value in the given row.
casacore::TSMDataColumn::canAccessArrayColumn
Bool canAccessArrayColumn(Bool &reask) const
It can handle access to an array column if there is one hypercube.
casacore::TSMDataColumn::putColumnSliceCellsInt64V
virtual void putColumnSliceCellsInt64V(const RefRows &rownrs, const Slicer &ns, const Array< Int64 > *dataPtr)
casacore::TSMDataColumn::getArrayuCharV
void getArrayuCharV(uInt rownr, Array< uChar > *dataPtr)
casacore::TSMDataColumn::putColumnSliceCellsuShortV
virtual void putColumnSliceCellsuShortV(const RefRows &rownrs, const Slicer &ns, const Array< uShort > *dataPtr)
casacore::TSMDataColumn::~TSMDataColumn
virtual ~TSMDataColumn()
Frees up the storage.
casacore::TSMDataColumn::getArrayColumnCellsInt64V
virtual void getArrayColumnCellsInt64V(const RefRows &rownrs, Array< Int64 > *dataPtr)
casacore::TSMDataColumn::getuCharV
void getuCharV(uInt rownr, uChar *dataPtr)
casacore::TSMDataColumn::putArrayColumnuCharV
void putArrayColumnuCharV(const Array< uChar > *arr)
casacore::TSMDataColumn::setShape
void setShape(uInt rownr, const IPosition &shape)
Set the shape of the data array in the given row.
casacore::TSMDataColumn::putArrayColumnCellsDComplexV
virtual void putArrayColumnCellsDComplexV(const RefRows &rownrs, const Array< DComplex > *dataPtr)
casacore::TSMDataColumn::putScalarColumnCellsShortV
virtual void putScalarColumnCellsShortV(const RefRows &rownrs, const Vector< Short > *dataPtr)
casacore::TSMDataColumn::putArrayuIntV
void putArrayuIntV(uInt rownr, const Array< uInt > *dataPtr)
casacore::TSMDataColumn::putColumnSliceCellsComplexV
virtual void putColumnSliceCellsComplexV(const RefRows &rownrs, const Slicer &ns, const Array< Complex > *dataPtr)
casacore::TSMDataColumn::getdoubleV
void getdoubleV(uInt rownr, double *dataPtr)
casacore::TSMDataColumn::getColumnSliceInt64V
void getColumnSliceInt64V(const Slicer &slicer, Array< Int64 > *arr)
casacore::TSMDataColumn::getArrayColumnCellsuCharV
virtual void getArrayColumnCellsuCharV(const RefRows &rownrs, Array< uChar > *dataPtr)
casacore::TSMDataColumn::getColumnSliceuIntV
void getColumnSliceuIntV(const Slicer &slicer, Array< uInt > *arr)
casacore::TSMDataColumn::putShortV
void putShortV(uInt rownr, const Short *dataPtr)
casacore::TSMDataColumn::getNrConvert
size_t getNrConvert() const
Get nr of elements in a value to convert (usually 1, but 2 for Complex).
Definition: TSMDataColumn.h:565
casacore::TSMDataColumn::getArrayColumnIntV
void getArrayColumnIntV(Array< Int > *arr)
casacore::TSMDataColumn::accessColumnCells
void accessColumnCells(const RefRows &rownrs, const IPosition &shape, const void *dataPtr, Bool writeFlag)
Read or write some cells in a column.
Complexfwd_global_functions_Complexfwd::casacore::DComplex
std::complex< Double > DComplex
Definition: Complexfwd.h:50
casacore::TSMDataColumn::accessColumnSlice
void accessColumnSlice(const Slicer &ns, const void *dataPtr, Bool writeFlag)
Read or write a slice from the entire column.
casacore::TSMDataColumn::getScalarColumnCellsIntV
virtual void getScalarColumnCellsIntV(const RefRows &rownrs, Vector< Int > *dataPtr)
casacore::TSMDataColumn::accessSlicedCells
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.
casacore::TSMDataColumn::canAccessColumnSlice
Bool canAccessColumnSlice(Bool &reask) const
It can handle access to a slice in column if there is one hypercube.
casacore::TSMDataColumn::getArrayIntV
void getArrayIntV(uInt rownr, Array< Int > *dataPtr)
casacore::TSMDataColumn::putSlicefloatV
void putSlicefloatV(uInt rownr, const Slicer &slicer, const Array< float > *dataPtr)
casacore::TSMDataColumn::writeFunc_p
Conversion::ValueFunction * writeFunc_p
The conversion function needed when writing.
Definition: TSMDataColumn.h:587
casacore::TSMDataColumn::putScalarColumnCellsBoolV
virtual void putScalarColumnCellsBoolV(const RefRows &rownrs, const Vector< Bool > *dataPtr)
Put the scalar values into some cells of the column.
casacore::TSMDataColumn::putSliceuIntV
void putSliceuIntV(uInt rownr, const Slicer &slicer, const Array< uInt > *dataPtr)
casacore::uChar
unsigned char uChar
Definition: aipstype.h:47
casacore::TSMCube
Definition: TSMCube.h:106
casacore::TSMDataColumn::putColumnSliceCellsuCharV
virtual void putColumnSliceCellsuCharV(const RefRows &rownrs, const Slicer &ns, const Array< uChar > *dataPtr)
casacore::TSMDataColumn::readFunc_p
Conversion::ValueFunction * readFunc_p
The conversion function needed when reading.
Definition: TSMDataColumn.h:585
casacore::TSMDataColumn::putArrayfloatV
void putArrayfloatV(uInt rownr, const Array< float > *dataPtr)
casacore::TSMDataColumn::TSMDataColumn
TSMDataColumn(const TSMDataColumn &)
Forbid copy constructor.
casacore::TSMDataColumn::getSliceuCharV
void getSliceuCharV(uInt rownr, const Slicer &slicer, Array< uChar > *dataPtr)
casacore::TSMDataColumn::getScalarColumndoubleV
void getScalarColumndoubleV(Vector< double > *arr)
casacore::TSMDataColumn::getSlicedoubleV
void getSlicedoubleV(uInt rownr, const Slicer &slicer, Array< double > *dataPtr)
casacore::TSMDataColumn::getColumnSliceCellsDComplexV
virtual void getColumnSliceCellsDComplexV(const RefRows &rownrs, const Slicer &ns, Array< DComplex > *dataPtr)
casacore::TSMDataColumn::shape
IPosition shape(uInt rownr)
Get the shape of the item in the given row.
casacore::TSMDataColumn::convPixelSize_p
uInt convPixelSize_p
The multiplication factor for a conversion operation.
Definition: TSMDataColumn.h:579
casacore::TSMDataColumn::getArrayColumnInt64V
void getArrayColumnInt64V(Array< Int64 > *arr)
casacore::TSMDataColumn::setColumnNumber
void setColumnNumber(uInt colnr)
Set column sequence number.
Definition: TSMDataColumn.h:650
casacore::TSMDataColumn::getArraydoubleV
void getArraydoubleV(uInt rownr, Array< double > *dataPtr)
casacore::TSMDataColumn::putScalarColumnuShortV
void putScalarColumnuShortV(const Vector< uShort > *arr)
casacore::TSMDataColumn::getArrayColumnComplexV
void getArrayColumnComplexV(Array< Complex > *arr)
casacore::TSMDataColumn::getScalarColumnCellsComplexV
virtual void getScalarColumnCellsComplexV(const RefRows &rownrs, Vector< Complex > *dataPtr)
casacore::TSMDataColumn::putSliceInt64V
void putSliceInt64V(uInt rownr, const Slicer &slicer, const Array< Int64 > *dataPtr)
casacore::TSMDataColumn::putScalarColumnComplexV
void putScalarColumnComplexV(const Vector< Complex > *arr)
casacore::TSMDataColumn::putIntV
void putIntV(uInt rownr, const Int *dataPtr)
casacore::TSMDataColumn::getScalarColumnCellsDComplexV
virtual void getScalarColumnCellsDComplexV(const RefRows &rownrs, Vector< DComplex > *dataPtr)
casacore::TSMDataColumn::getArrayColumnCellsuIntV
virtual void getArrayColumnCellsuIntV(const RefRows &rownrs, Array< uInt > *dataPtr)
casacore::TSMDataColumn::getSliceuIntV
void getSliceuIntV(uInt rownr, const Slicer &slicer, Array< uInt > *dataPtr)
casacore::TSMDataColumn::putScalarColumnCellsuIntV
virtual void putScalarColumnCellsuIntV(const RefRows &rownrs, const Vector< uInt > *dataPtr)
casacore::TSMDataColumn::getScalarColumnfloatV
void getScalarColumnfloatV(Vector< float > *arr)
casacore::TSMDataColumn::getArrayfloatV
void getArrayfloatV(uInt rownr, Array< float > *dataPtr)
casacore::TSMDataColumn::getScalarColumnIntV
void getScalarColumnIntV(Vector< Int > *arr)
casacore::TSMDataColumn::getArrayColumnCellsComplexV
virtual void getArrayColumnCellsComplexV(const RefRows &rownrs, Array< Complex > *dataPtr)
casacore::TSMDataColumn::getScalarColumnCellsuCharV
virtual void getScalarColumnCellsuCharV(const RefRows &rownrs, Vector< uChar > *dataPtr)
casacore::TSMDataColumn::putColumnSlicedoubleV
void putColumnSlicedoubleV(const Slicer &slicer, const Array< double > *dataPtr)
casacore::TSMDataColumn::accessCell
void accessCell(uInt rownr, const void *dataPtr, Bool writeFlag)
Read or write a data cell in the cube.
casacore::TSMDataColumn::putScalarColumnIntV
void putScalarColumnIntV(const Vector< Int > *arr)
casacore::TSMDataColumn::tilePixelSize
uInt tilePixelSize() const
Return the size of a pixel in the tile in external format.
Definition: TSMDataColumn.h:642
casacore::TSMDataColumn::getuIntV
void getuIntV(uInt rownr, uInt *dataPtr)
casacore::TSMDataColumn::canChangeShape
Bool canChangeShape() const
Changing array shapes for non-FixedShape columns when the parent tiled storage manager can handle it.
casacore::TSMDataColumn::putArrayColumnInt64V
void putArrayColumnInt64V(const Array< Int64 > *arr)
casacore::TSMDataColumn::getArrayShortV
void getArrayShortV(uInt rownr, Array< Short > *dataPtr)
casacore::TSMDataColumn::putfloatV
void putfloatV(uInt rownr, const float *dataPtr)
casacore::TSMDataColumn::putArrayColumnfloatV
void putArrayColumnfloatV(const Array< float > *arr)
casacore::TSMDataColumn::putColumnSliceuShortV
void putColumnSliceuShortV(const Slicer &slicer, const Array< uShort > *dataPtr)
casacore::TSMDataColumn::putColumnSliceCellsIntV
virtual void putColumnSliceCellsIntV(const RefRows &rownrs, const Slicer &ns, const Array< Int > *dataPtr)
casacore::TSMDataColumn::getColumnSliceCellsShortV
virtual void getColumnSliceCellsShortV(const RefRows &rownrs, const Slicer &ns, Array< Short > *dataPtr)
casacore::TSMDataColumn::getScalarColumnCellsBoolV
virtual void getScalarColumnCellsBoolV(const RefRows &rownrs, Vector< Bool > *dataPtr)
Get the scalar values in some cells of the column.
casacore::TSMDataColumn::putColumnSliceCellsDComplexV
virtual void putColumnSliceCellsDComplexV(const RefRows &rownrs, const Slicer &ns, const Array< DComplex > *dataPtr)
casacore::TSMDataColumn::getIntV
void getIntV(uInt rownr, Int *dataPtr)
casacore::TSMDataColumn::putScalarColumndoubleV
void putScalarColumndoubleV(const Vector< double > *arr)
casacore::TSMDataColumn::getArrayColumnCellsBoolV
virtual void getArrayColumnCellsBoolV(const RefRows &rownrs, Array< Bool > *dataPtr)
Get the array values in some cells of the column.
casacore::TSMDataColumn::getArrayColumnCellsIntV
virtual void getArrayColumnCellsIntV(const RefRows &rownrs, Array< Int > *dataPtr)
casacore::TSMDataColumn::canAccessSlice
Bool canAccessSlice(Bool &reask) const
It can handle access to a slice in a cell.
casacore::TSMDataColumn::putArraydoubleV
void putArraydoubleV(uInt rownr, const Array< double > *dataPtr)
casacore::TSMDataColumn::localPixelSize_p
uInt localPixelSize_p
The local size of a pixel.
Definition: TSMDataColumn.h:576
casacore::TSMDataColumn::putColumnSliceCellsdoubleV
virtual void putColumnSliceCellsdoubleV(const RefRows &rownrs, const Slicer &ns, const Array< double > *dataPtr)
casacore::TSMDataColumn::getSliceComplexV
void getSliceComplexV(uInt rownr, const Slicer &slicer, Array< Complex > *dataPtr)
casacore::TSMDataColumn::getScalarColumnCellsuShortV
virtual void getScalarColumnCellsuShortV(const RefRows &rownrs, Vector< uShort > *dataPtr)
casacore::TSMDataColumn::getColumnSliceComplexV
void getColumnSliceComplexV(const Slicer &slicer, Array< Complex > *arr)
casacore::TSMDataColumn::getColumnSliceCellsBoolV
virtual void getColumnSliceCellsBoolV(const RefRows &rownrs, const Slicer &ns, Array< Bool > *dataPtr)
Get the array values in some cells of the column.
casacore::TSMDataColumn::putSliceuCharV
void putSliceuCharV(uInt rownr, const Slicer &slicer, const Array< uChar > *dataPtr)
casacore::TSMDataColumn::putScalarColumnCellsuCharV
virtual void putScalarColumnCellsuCharV(const RefRows &rownrs, const Vector< uChar > *dataPtr)
casacore::TSMDataColumn::accessFullCells
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.
casacore::TSMDataColumn::putColumnSliceBoolV
void putColumnSliceBoolV(const Slicer &slicer, const Array< Bool > *dataPtr)
Put the array values into the entire column.
casacore::TSMDataColumn::putScalarColumnCellsComplexV
virtual void putScalarColumnCellsComplexV(const RefRows &rownrs, const Vector< Complex > *dataPtr)
casacore::uShort
unsigned short uShort
Definition: aipstype.h:49
casacore::TSMDataColumn
Definition: TSMDataColumn.h:97
casacore::TSMDataColumn::putSliceComplexV
void putSliceComplexV(uInt rownr, const Slicer &slicer, const Array< Complex > *dataPtr)
casacore::TSMDataColumn::putColumnSliceComplexV
void putColumnSliceComplexV(const Slicer &slicer, const Array< Complex > *dataPtr)
casacore::TSMDataColumn::accessColumnSliceCells
void accessColumnSliceCells(const RefRows &rownrs, const Slicer &ns, const IPosition &shape, const void *dataPtr, Bool writeFlag)
Read or write some cells in a column.
casacore::TSMDataColumn::putuShortV
void putuShortV(uInt rownr, const uShort *dataPtr)
casacore::TSMDataColumn::getArrayInt64V
void getArrayInt64V(uInt rownr, Array< Int64 > *dataPtr)
casacore::RefRows
Definition: RefRows.h:86
casacore::TSMDataColumn::getArrayColumnuShortV
void getArrayColumnuShortV(Array< uShort > *arr)
casacore::TSMDataColumn::putSliceIntV
void putSliceIntV(uInt rownr, const Slicer &slicer, const Array< Int > *dataPtr)
casacore::TSMDataColumn::putArrayColumnuIntV
void putArrayColumnuIntV(const Array< uInt > *arr)
casacore::TSMDataColumn::putArrayColumnIntV
void putArrayColumnIntV(const Array< Int > *arr)
casacore::TSMDataColumn::getColumnSliceIntV
void getColumnSliceIntV(const Slicer &slicer, Array< Int > *arr)
casacore::uInt
unsigned int uInt
Definition: aipstype.h:51
casacore::TSMDataColumn::getSlicefloatV
void getSlicefloatV(uInt rownr, const Slicer &slicer, Array< float > *dataPtr)
casacore::TSMDataColumn::getScalarColumnCellsuIntV
virtual void getScalarColumnCellsuIntV(const RefRows &rownrs, Vector< uInt > *dataPtr)
casacore::TSMDataColumn::putScalarColumnCellsuShortV
virtual void putScalarColumnCellsuShortV(const RefRows &rownrs, const Vector< uShort > *dataPtr)
casacore::TSMDataColumn::getScalarColumnBoolV
void getScalarColumnBoolV(Vector< Bool > *arr)
Get the scalar values in the entire column.
casacore::TSMDataColumn::putArrayColumndoubleV
void putArrayColumndoubleV(const Array< double > *arr)
casacore::TSMDataColumn::putArrayColumnBoolV
void putArrayColumnBoolV(const Array< Bool > *arr)
Put the array values into the entire column.
casacore::TSMDataColumn::putuIntV
void putuIntV(uInt rownr, const uInt *dataPtr)
casacore::TSMDataColumn::getShortV
void getShortV(uInt rownr, Short *dataPtr)
casacore::TSMDataColumn::getScalarColumnDComplexV
void getScalarColumnDComplexV(Vector< DComplex > *arr)
casacore::TSMDataColumn::getArrayColumndoubleV
void getArrayColumndoubleV(Array< double > *arr)
casacore::TSMDataColumn::putColumnSliceuIntV
void putColumnSliceuIntV(const Slicer &slicer, const Array< uInt > *dataPtr)
casacore::TSMDataColumn::putSliceBoolV
void putSliceBoolV(uInt rownr, const Slicer &slicer, const Array< Bool > *dataPtr)
Put the array value into the given row.
casacore::TSMDataColumn::putScalarColumnfloatV
void putScalarColumnfloatV(const Vector< float > *arr)
casacore::TSMDataColumn::isConversionNeeded
Bool isConversionNeeded() const
Does a conversion (byte swap) needs to be done?
Definition: TSMDataColumn.h:569
casacore::TSMDataColumn::putArrayDComplexV
void putArrayDComplexV(uInt rownr, const Array< DComplex > *dataPtr)
casacore::TSMDataColumn::getScalarColumnComplexV
void getScalarColumnComplexV(Vector< Complex > *arr)
casacore::TSMDataColumn::getColumnSliceuCharV
void getColumnSliceuCharV(const Slicer &slicer, Array< uChar > *arr)
casacore::TSMDataColumn::putComplexV
void putComplexV(uInt rownr, const Complex *dataPtr)
casacore::TSMDataColumn::putArrayuCharV
void putArrayuCharV(uInt rownr, const Array< uChar > *dataPtr)
casacore::TSMDataColumn::putScalarColumnInt64V
void putScalarColumnInt64V(const Vector< Int64 > *arr)
casacore::TSMDataColumn::putColumnSliceInt64V
void putColumnSliceInt64V(const Slicer &slicer, const Array< Int64 > *dataPtr)
casacore::TSMDataColumn::getColumnSliceuShortV
void getColumnSliceuShortV(const Slicer &slicer, Array< uShort > *arr)
casacore::TSMDataColumn::putScalarColumnCellsdoubleV
virtual void putScalarColumnCellsdoubleV(const RefRows &rownrs, const Vector< double > *dataPtr)
casacore::TSMDataColumn::getColumnSliceCellsfloatV
virtual void getColumnSliceCellsfloatV(const RefRows &rownrs, const Slicer &ns, Array< float > *dataPtr)
casacore::Int
int Int
Definition: aipstype.h:50
casacore
this file contains all the compiler specific defines
Definition: mainpage.dox:28
casacore::TSMDataColumn::putArrayColumnCellsfloatV
virtual void putArrayColumnCellsfloatV(const RefRows &rownrs, const Array< float > *dataPtr)
casacore::TSMDataColumn::putArrayColumnCellsComplexV
virtual void putArrayColumnCellsComplexV(const RefRows &rownrs, const Array< Complex > *dataPtr)
casacore::TSMDataColumn::putScalarColumnuCharV
void putScalarColumnuCharV(const Vector< uChar > *arr)
casacore::TSMDataColumn::putArrayColumnCellsuCharV
virtual void putArrayColumnCellsuCharV(const RefRows &rownrs, const Array< uChar > *dataPtr)
casacore::TSMDataColumn::getSliceInt64V
void getSliceInt64V(uInt rownr, const Slicer &slicer, Array< Int64 > *dataPtr)
casacore::TSMDataColumn::getScalarColumnInt64V
void getScalarColumnInt64V(Vector< Int64 > *arr)
casacore::TSMDataColumn::writeTile
void writeTile(void *to, const void *from, uInt nrPixels)
Write the data of the column into a tile.
Definition: TSMDataColumn.h:659
casacore::TSMDataColumn::putDComplexV
void putDComplexV(uInt rownr, const DComplex *dataPtr)
casacore::TSMDataColumn::putdoubleV
void putdoubleV(uInt rownr, const double *dataPtr)
casacore::TSMDataColumn::putArrayColumnCellsuShortV
virtual void putArrayColumnCellsuShortV(const RefRows &rownrs, const Array< uShort > *dataPtr)
casacore::TSMDataColumn::putArrayColumnCellsShortV
virtual void putArrayColumnCellsShortV(const RefRows &rownrs, const Array< Short > *dataPtr)
casacore::TSMDataColumn::putArrayBoolV
void putArrayBoolV(uInt rownr, const Array< Bool > *dataPtr)
Put the array value into the given row.
casacore::TSMDataColumn::getArrayColumnDComplexV
void getArrayColumnDComplexV(Array< DComplex > *arr)
casacore::TSMDataColumn::putColumnSliceShortV
void putColumnSliceShortV(const Slicer &slicer, const Array< Short > *dataPtr)
casacore::TSMDataColumn::getColumnSliceCellsuIntV
virtual void getColumnSliceCellsuIntV(const RefRows &rownrs, const Slicer &ns, Array< uInt > *dataPtr)
casacore::TSMDataColumn::putArrayColumnuShortV
void putArrayColumnuShortV(const Array< uShort > *arr)
casacore::TSMDataColumn::getArrayBoolV
void getArrayBoolV(uInt rownr, Array< Bool > *dataPtr)
Get the array value in the given row.
casacore::TSMDataColumn::putScalarColumnuIntV
void putScalarColumnuIntV(const Vector< uInt > *arr)
casacore::TSMDataColumn::getDComplexV
void getDComplexV(uInt rownr, DComplex *dataPtr)
casacore::TSMDataColumn::getScalarColumnuCharV
void getScalarColumnuCharV(Vector< uChar > *arr)
casacore::TSMDataColumn::getArrayColumnCellsShortV
virtual void getArrayColumnCellsShortV(const RefRows &rownrs, Array< Short > *dataPtr)
casacore::TSMDataColumn::getSliceShortV
void getSliceShortV(uInt rownr, const Slicer &slicer, Array< Short > *dataPtr)
casacore::TSMDataColumn::isShapeDefined
Bool isShapeDefined(uInt rownr)
Is the value shape defined in the given row?
casacore::TSMDataColumn::getColumnSliceCellsuShortV
virtual void getColumnSliceCellsuShortV(const RefRows &rownrs, const Slicer &ns, Array< uShort > *dataPtr)
casacore::TSMDataColumn::putColumnSliceDComplexV
void putColumnSliceDComplexV(const Slicer &slicer, const Array< DComplex > *dataPtr)
casacore::TSMDataColumn::getColumnSliceShortV
void getColumnSliceShortV(const Slicer &slicer, Array< Short > *arr)
casacore::TSMDataColumn::getScalarColumnCellsfloatV
virtual void getScalarColumnCellsfloatV(const RefRows &rownrs, Vector< float > *dataPtr)
casacore::TSMDataColumn::getInt64V
void getInt64V(uInt rownr, Int64 *dataPtr)
casacore::TSMDataColumn::getComplexV
void getComplexV(uInt rownr, Complex *dataPtr)
casacore::TSMDataColumn::getuShortV
void getuShortV(uInt rownr, uShort *dataPtr)
casacore::TSMDataColumn::putColumnSliceCellsfloatV
virtual void putColumnSliceCellsfloatV(const RefRows &rownrs, const Slicer &ns, const Array< float > *dataPtr)
casacore::TSMDataColumn::putSliceDComplexV
void putSliceDComplexV(uInt rownr, const Slicer &slicer, const Array< DComplex > *dataPtr)
casacore::TSMDataColumn::tilePixelSize_p
uInt tilePixelSize_p
The (canonical) size of a pixel in a tile.
Definition: TSMDataColumn.h:574
casacore::TSMDataColumn::putArrayColumnDComplexV
void putArrayColumnDComplexV(const Array< DComplex > *arr)
casacore::TSMDataColumn::getConvertFunction
Conversion::ValueFunction * getConvertFunction(Bool writeFlag) const
Get the function to convert from external to local format (or vice-versa if writeFlag=True).
Definition: TSMDataColumn.h:561
casacore::Int64
long long Int64
Define the extra non-standard types used by Casacore (like proposed uSize, Size)
Definition: aipsxtype.h:38
casacore::TSMDataColumn::getArrayColumnCellsdoubleV
virtual void getArrayColumnCellsdoubleV(const RefRows &rownrs, Array< double > *dataPtr)
casacore::TSMDataColumn::putArrayuShortV
void putArrayuShortV(uInt rownr, const Array< uShort > *dataPtr)
casacore::TSMDataColumn::putScalarColumnBoolV
void putScalarColumnBoolV(const Vector< Bool > *arr)
Put the scalar values into the entire column.
casacore::TSMColumn
Definition: TSMColumn.h:98
casacore::TSMDataColumn::getScalarColumnCellsdoubleV
virtual void getScalarColumnCellsdoubleV(const RefRows &rownrs, Vector< double > *dataPtr)
casacore::Array< Bool >
casacore::TSMDataColumn::getColumnSliceCellsInt64V
virtual void getColumnSliceCellsInt64V(const RefRows &rownrs, const Slicer &ns, Array< Int64 > *dataPtr)
casacore::TSMDataColumn::localPixelSize
uInt localPixelSize() const
Return the size of a pixel in the tile in local format.
Definition: TSMDataColumn.h:646
casacore::TSMDataColumn::getColumnSliceCellsIntV
virtual void getColumnSliceCellsIntV(const RefRows &rownrs, const Slicer &ns, Array< Int > *dataPtr)
casacore::TSMDataColumn::getArrayColumnCellsuShortV
virtual void getArrayColumnCellsuShortV(const RefRows &rownrs, Array< uShort > *dataPtr)
casacore::TSMDataColumn::putColumnSliceCellsShortV
virtual void putColumnSliceCellsShortV(const RefRows &rownrs, const Slicer &ns, const Array< Short > *dataPtr)
casacore::TSMDataColumn::putColumnSliceIntV
void putColumnSliceIntV(const Slicer &slicer, const Array< Int > *dataPtr)
casacore::Conversion::ValueFunction
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
casacore::TSMDataColumn::putBoolV
void putBoolV(uInt rownr, const Bool *dataPtr)
Put a scalar value into the given row.
casacore::TSMDataColumn::putArrayShortV
void putArrayShortV(uInt rownr, const Array< Short > *dataPtr)
casacore::TSMDataColumn::accessColumn
void accessColumn(const void *dataPtr, Bool writeFlag)
Read or write an entire column.
casacore::TSMDataColumn::getArrayuIntV
void getArrayuIntV(uInt rownr, Array< uInt > *dataPtr)
casacore::Bool
bool Bool
Define the standard types used by Casacore.
Definition: aipstype.h:42
casacore::TSMDataColumn::getArrayColumnBoolV
void getArrayColumnBoolV(Array< Bool > *arr)
Get the array values in the entire column.
Complexfwd_global_functions_Complexfwd::casacore::Complex
std::complex< Float > Complex
Definition: Complexfwd.h:49
casacore::TSMDataColumn::getArrayComplexV
void getArrayComplexV(uInt rownr, Array< Complex > *dataPtr)
casacore::TSMDataColumn::putColumnSliceCellsBoolV
virtual void putColumnSliceCellsBoolV(const RefRows &rownrs, const Slicer &ns, const Array< Bool > *dataPtr)
Put the array values into some cells of the column.
casacore::TSMDataColumn::getColumnSliceCellsuCharV
virtual void getColumnSliceCellsuCharV(const RefRows &rownrs, const Slicer &ns, Array< uChar > *dataPtr)
casacore::TSMDataColumn::colnr_p
uInt colnr_p
The column sequence number.
Definition: TSMDataColumn.h:583
casacore::TSMDataColumn::putArrayColumnCellsInt64V
virtual void putArrayColumnCellsInt64V(const RefRows &rownrs, const Array< Int64 > *dataPtr)
casacore::TSMDataColumn::getScalarColumnShortV
void getScalarColumnShortV(Vector< Short > *arr)
casacore::TSMDataColumn::putuCharV
void putuCharV(uInt rownr, const uChar *dataPtr)
casacore::TSMDataColumn::getArrayuShortV
void getArrayuShortV(uInt rownr, Array< uShort > *dataPtr)
casacore::TSMDataColumn::getColumnSliceDComplexV
void getColumnSliceDComplexV(const Slicer &slicer, Array< DComplex > *arr)
casacore::Short
short Short
Definition: aipstype.h:48
casacore::TSMDataColumn::mustConvert_p
Bool mustConvert_p
Is a conversion necessary?
Definition: TSMDataColumn.h:581
casacore::TSMDataColumn::tileShape
IPosition tileShape(uInt rownr)
Get the tile shape of the item in the given row.
casacore::TSMDataColumn::putColumnSliceuCharV
void putColumnSliceuCharV(const Slicer &slicer, const Array< uChar > *dataPtr)
casacore::TSMDataColumn::getArrayColumnfloatV
void getArrayColumnfloatV(Array< float > *arr)
casacore::Vector< Bool >
casacore::TSMDataColumn::putScalarColumnCellsIntV
virtual void putScalarColumnCellsIntV(const RefRows &rownrs, const Vector< Int > *dataPtr)
casacore::TSMDataColumn::putArrayColumnCellsBoolV
virtual void putArrayColumnCellsBoolV(const RefRows &rownrs, const Array< Bool > *dataPtr)
Put the array values into some cells of the column.
casacore::TSMDataColumn::getArrayDComplexV
void getArrayDComplexV(uInt rownr, Array< DComplex > *dataPtr)
casacore::TSMDataColumn::accessCellSlice
void accessCellSlice(uInt rownr, const Slicer &ns, const void *dataPtr, Bool writeFlag)
Read or write a slice of a data cell in the cube.
casacore::TSMDataColumn::getScalarColumnuIntV
void getScalarColumnuIntV(Vector< uInt > *arr)
casacore::TSMDataColumn::readTile
void readTile(void *to, const void *from, uInt nrPixels)
Read the data of the column from a tile.
Definition: TSMDataColumn.h:654
casacore::TSMDataColumn::putScalarColumnCellsInt64V
virtual void putScalarColumnCellsInt64V(const RefRows &rownrs, const Vector< Int64 > *dataPtr)
casacore::TSMDataColumn::getSliceDComplexV
void getSliceDComplexV(uInt rownr, const Slicer &slicer, Array< DComplex > *dataPtr)
casacore::TSMDataColumn::getArrayColumnuIntV
void getArrayColumnuIntV(Array< uInt > *arr)
casacore::TSMDataColumn::putScalarColumnCellsfloatV
virtual void putScalarColumnCellsfloatV(const RefRows &rownrs, const Vector< float > *dataPtr)
casacore::TSMDataColumn::dataLength
uInt dataLength(uInt nrPixels) const
Determine the length to store the given number of pixels.
casacore::TSMDataColumn::putColumnSliceCellsuIntV
virtual void putColumnSliceCellsuIntV(const RefRows &rownrs, const Slicer &ns, const Array< uInt > *dataPtr)
casacore::TSMDataColumn::putScalarColumnShortV
void putScalarColumnShortV(const Vector< Short > *arr)
casacore::TSMDataColumn::getArrayColumnCellsfloatV
virtual void getArrayColumnCellsfloatV(const RefRows &rownrs, Array< float > *dataPtr)
casacore::TSMDataColumn::putArrayColumnCellsuIntV
virtual void putArrayColumnCellsuIntV(const RefRows &rownrs, const Array< uInt > *dataPtr)
casacore::TSMDataColumn::setShapeTiled
void setShapeTiled(uInt rownr, const IPosition &shape, const IPosition &tileShape)
Set the shape and tile shape of the array in the given row.
casacore::TSMDataColumn::getColumnSliceCellsdoubleV
virtual void getColumnSliceCellsdoubleV(const RefRows &rownrs, const Slicer &ns, Array< double > *dataPtr)
casacore::TSMDataColumn::getfloatV
void getfloatV(uInt rownr, float *dataPtr)
casacore::TSMDataColumn::getScalarColumnCellsInt64V
virtual void getScalarColumnCellsInt64V(const RefRows &rownrs, Vector< Int64 > *dataPtr)
casacore::TSMDataColumn::putArrayComplexV
void putArrayComplexV(uInt rownr, const Array< Complex > *dataPtr)
casacore::TSMDataColumn::putColumnSlicefloatV
void putColumnSlicefloatV(const Slicer &slicer, const Array< float > *dataPtr)
casacore::TSMDataColumn::getColumnSliceCellsComplexV
virtual void getColumnSliceCellsComplexV(const RefRows &rownrs, const Slicer &ns, Array< Complex > *dataPtr)
casacore::TSMDataColumn::putSlicedoubleV
void putSlicedoubleV(uInt rownr, const Slicer &slicer, const Array< double > *dataPtr)
casacore::TSMDataColumn::putArrayColumnCellsIntV
virtual void putArrayColumnCellsIntV(const RefRows &rownrs, const Array< Int > *dataPtr)
casacore::TSMDataColumn::getArrayColumnuCharV
void getArrayColumnuCharV(Array< uChar > *arr)
casacore::TSMDataColumn::getColumnSlicedoubleV
void getColumnSlicedoubleV(const Slicer &slicer, Array< double > *arr)
casacore::TSMDataColumn::getScalarColumnuShortV
void getScalarColumnuShortV(Vector< uShort > *arr)
casacore::TSMDataColumn::putArrayInt64V
void putArrayInt64V(uInt rownr, const Array< Int64 > *dataPtr)
casacore::TSMDataColumn::getScalarColumnCellsShortV
virtual void getScalarColumnCellsShortV(const RefRows &rownrs, Vector< Short > *dataPtr)
casacore::TSMDataColumn::putArrayColumnShortV
void putArrayColumnShortV(const Array< Short > *arr)
casacore::TSMDataColumn::putArrayColumnComplexV
void putArrayColumnComplexV(const Array< Complex > *arr)
casacore::TSMDataColumn::putSliceShortV
void putSliceShortV(uInt rownr, const Slicer &slicer, const Array< Short > *dataPtr)
casacore::TSMDataColumn::putArrayIntV
void putArrayIntV(uInt rownr, const Array< Int > *dataPtr)
casacore::TSMDataColumn::putSliceuShortV
void putSliceuShortV(uInt rownr, const Slicer &slicer, const Array< uShort > *dataPtr)