casacore
StIndArray.h
Go to the documentation of this file.
1 //# StIndArray.h: Read/write indirect arrays
2 //# Copyright (C) 1994,1995,1996,1997,1999,2001
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_STINDARRAY_H
29 #define TABLES_STINDARRAY_H
30 
31 //# Includes
32 #include <casacore/casa/aips.h>
33 #include <casacore/tables/DataMan/StArrayFile.h>
34 #include <casacore/casa/Arrays/IPosition.h>
35 #include <casacore/casa/BasicSL/Complex.h>
36 
37 namespace casacore { //# NAMESPACE CASACORE - BEGIN
38 
39 //# Forward Declarations
40 class Slicer;
41 template<class T> class Array;
42 
43 
44 // <summary>
45 // Read/write indirect arrays
46 // </summary>
47 
48 // <use visibility=local>
49 
50 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
51 // </reviewed>
52 
53 // <prerequisite>
54 //# Classes you should understand before using this one.
55 // <li> StManArrayFile
56 // </prerequisite>
57 
58 // <etymology>
59 // StIndArray stores indirect arrays on behalf of a storage manager.
60 // </etymology>
61 
62 // <synopsis>
63 // StIndArray is a helper class for accessing indirect table arrays.
64 // It is the interface between a storage manager like StManAipsIO
65 // (in particular its indirect array column class
66 // <linkto class="StManColumnIndArrayAipsIO:description">
67 // StManColumnIndArrayAipsIO</linkto>)
68 // and the data storage class
69 // <linkto class="StManArrayFile:description">StManArrayFile</linkto>
70 // which represents the file holding the shapes and data of the arrays.
71 // This file holds the data in canonical format.
72 //
73 // StIndArray holds information about an array in the file.
74 // <ol>
75 // <li> Offset of the array in the file. This points to the array shape.
76 // This is stored by storage managers and serves as the mapping between
77 // row number and array.
78 // <li> Array data offset, i.e. the length of the shape in the file.
79 // Because the data is stored in canonical format, the length of the
80 // shape in the file is not directly known but has to be supplied this way.
81 // <li> The actual shape of the array
82 // </ol>
83 // The storage manager creates an StIndArray object for each row.
84 // When an array is accessed for the first time,
85 // the array data offset and the shape will be filled in by StIndArray.
86 // In this way it serves as a cache for the array shape.
87 //
88 // StIndArray implements all necessary functions to get/put an array or
89 // an array slice from/into file supplied by the given StManArrayFile object.
90 // The StManArrayFile object itself has to be created by the storage manager
91 // and given to the StIndArray functions.
92 // </synopsis>
93 
94 // <motivation>
95 // This helper class makes it possible to share equal functionality
96 // between various storage managers handling indirect arrays.
97 // At the moment it is used by StmanColumnIndArrayAipsIO and
98 // StManColumnIndArrayMirAIO (the AipsIO and Miriad-like storage
99 // manager, resp.), but it is not limited to them. It can equally
100 // well be used for any other storage manager storing (indirect) arrays
101 // via an StManArrayFile object.
102 // </motivation>
103 
104 // <example>
105 // Note that the following example is not really useful.
106 // StIndArray is an internal class and should not be used by a casual user.
107 // The example may however give a bit of insight.
108 // <srcblock>
109 // Array<Float> array(...);
110 // // Create an StManArrayFile object to hold the arrays.
111 // StManArrayFile stmanFile ("some.name", ByteIO::New);
112 // // Create a still empty StIndArray object for an array.
113 // StIndArray arrayRef(0);
114 // // Define the shape and allocate a Float array.
115 // // Put the array data.
116 // arrayRef.setShape (stmanFile, TpFloat, array.shape());
117 // arrayRef.putArrayfloatV (stmanFile, &array);
118 // // Get the file offset of the array (for later use).
119 // Int64 offset = arrayRef.fileOffset();
120 // // Create an StIndArray object to read the array back.
121 // // Of course, the same object could have been used for that purpose,
122 // // but this shows how to create one for an existing file.
123 // StIndArray arrayRef2(offset);
124 // arrayRef2.getShape (stmanFile); // read shape
125 // Array<float> array2(arrayRef2.shape()); // create with correct size
126 // arrayRef2.getArrayfloatV (stmanFile, &array2);
127 // </srcblock>
128 // </example>
129 
130 // <todo asof="$DATE:$">
131 //# A List of bugs, limitations, extensions or planned refinements.
132 // <li> Reuse file storage when an array gets reshaped.
133 // This could be done when the array does not grow.
134 // It also requires a change in StManArrayFile.
135 // <li> Be smarter when accessing slices by not accessing a vector
136 // at a time, but by determining and accessing the largest
137 // possible consecutive area.
138 // </todo>
139 
140 
142 {
143 public:
144  // Construct the object with the given file offset.
145  // A zero file offset means that no array has been defined yet.
146  // That may be filled in later by setShape.
147  StIndArray (Int64 fileOffset);
148 
149  // Copy constructor.
150  StIndArray (const StIndArray&);
151 
152  // Assignment.
154 
155  ~StIndArray();
156 
157  // Get the shape.
158  const IPosition& shape() const
159  {return shape_p;}
160 
161  // Get the file offset.
163  {return fileOffset_p;}
164 
165  // Set the shape and allocate the array in the file.
166  // This will define the array and fill in the file offset.
167  // If the shape is already defined and does not change,
168  // nothing is done and a False value is returned.
169  // When the shape changes, the old file space is lost.
170  Bool setShape (StManArrayFile&, int dataType, const IPosition& shape);
171 
172  // Read the shape if not read yet.
173  void getShape (StManArrayFile& ios);
174 
175  // Get the reference count.
177 
178  // Increment the reference count.
179  void incrementRefCount (StManArrayFile& ios);
180 
181  // Decrement the reference count.
182  void decrementRefCount (StManArrayFile& ios);
183 
184  // Copy the data from another array.
185  // An exception if thrown if the shapes do not match.
186  void copyData (StManArrayFile& ios, int dataType, const StIndArray& other);
187 
188  // Get an array value from the file at the offset held in this object.
189  // The buffer pointed to by dataPtr has to have the correct length
190  // (which is guaranteed by the ArrayColumn get function).
191  // <group>
192  void getArrayBoolV (StManArrayFile&, Array<Bool>* dataPtr);
193  void getArrayuCharV (StManArrayFile&, Array<uChar>* dataPtr);
194  void getArrayShortV (StManArrayFile&, Array<Short>* dataPtr);
195  void getArrayuShortV (StManArrayFile&, Array<uShort>* dataPtr);
196  void getArrayIntV (StManArrayFile&, Array<Int>* dataPtr);
197  void getArrayuIntV (StManArrayFile&, Array<uInt>* dataPtr);
198  void getArrayfloatV (StManArrayFile&, Array<float>* dataPtr);
199  void getArraydoubleV (StManArrayFile&, Array<double>* dataPtr);
202  void getArrayStringV (StManArrayFile&, Array<String>* dataPtr);
203  // </group>
204 
205  // Put an array value into the file at the offset held in this object.
206  // The buffer pointed to by dataPtr has to have the correct length
207  // (which is guaranteed by the ArrayColumn put function).
208  // <group>
209  void putArrayBoolV (StManArrayFile&, const Array<Bool>* dataPtr);
210  void putArrayuCharV (StManArrayFile&, const Array<uChar>* dataPtr);
211  void putArrayShortV (StManArrayFile&, const Array<Short>* dataPtr);
212  void putArrayuShortV (StManArrayFile&, const Array<uShort>* dataPtr);
213  void putArrayIntV (StManArrayFile&, const Array<Int>* dataPtr);
214  void putArrayuIntV (StManArrayFile&, const Array<uInt>* dataPtr);
215  void putArrayfloatV (StManArrayFile&, const Array<float>* dataPtr);
216  void putArraydoubleV (StManArrayFile&, const Array<double>* dataPtr);
217  void putArrayComplexV (StManArrayFile&, const Array<Complex>* dataPtr);
218  void putArrayDComplexV (StManArrayFile&, const Array<DComplex>* dataPtr);
219  void putArrayStringV (StManArrayFile&, const Array<String>* dataPtr);
220  // </group>
221 
222  // Get a section of the array from the file at the offset held in
223  // this object.
224  // The buffer pointed to by dataPtr has to have the correct length
225  // (which is guaranteed by the ArrayColumn getSlice function).
226  // <group>
227  void getSliceBoolV (StManArrayFile&, const Slicer&,
228  Array<Bool>* dataPtr);
229  void getSliceuCharV (StManArrayFile&, const Slicer&,
230  Array<uChar>* dataPtr);
231  void getSliceShortV (StManArrayFile&, const Slicer&,
232  Array<Short>* dataPtr);
233  void getSliceuShortV (StManArrayFile&, const Slicer&,
234  Array<uShort>* dataPtr);
235  void getSliceIntV (StManArrayFile&, const Slicer&,
236  Array<Int>* dataPtr);
237  void getSliceuIntV (StManArrayFile&, const Slicer&,
238  Array<uInt>* dataPtr);
239  void getSlicefloatV (StManArrayFile&, const Slicer&,
240  Array<float>* dataPtr);
241  void getSlicedoubleV (StManArrayFile&, const Slicer&,
242  Array<double>* dataPtr);
243  void getSliceComplexV (StManArrayFile&, const Slicer&,
244  Array<Complex>* dataPtr);
245  void getSliceDComplexV (StManArrayFile&, const Slicer&,
246  Array<DComplex>* dataPtr);
247  void getSliceStringV (StManArrayFile&, const Slicer&,
248  Array<String>* dataPtr);
249  // </group>
250 
251  // Put a section of the array into the file at the offset held in
252  // this object.
253  // The buffer pointed to by dataPtr has to have the correct length
254  // (which is guaranteed by the ArrayColumn putSlice function).
255  // <group>
256  void putSliceBoolV (StManArrayFile&, const Slicer&,
257  const Array<Bool>* dataPtr);
258  void putSliceuCharV (StManArrayFile&, const Slicer&,
259  const Array<uChar>* dataPtr);
260  void putSliceShortV (StManArrayFile&, const Slicer&,
261  const Array<Short>* dataPtr);
262  void putSliceuShortV (StManArrayFile&, const Slicer&,
263  const Array<uShort>* dataPtr);
264  void putSliceIntV (StManArrayFile&, const Slicer&,
265  const Array<Int>* dataPtr);
266  void putSliceuIntV (StManArrayFile&, const Slicer&,
267  const Array<uInt>* dataPtr);
268  void putSlicefloatV (StManArrayFile&, const Slicer&,
269  const Array<float>* dataPtr);
270  void putSlicedoubleV (StManArrayFile&, const Slicer&,
271  const Array<double>* dataPtr);
272  void putSliceComplexV (StManArrayFile&, const Slicer&,
273  const Array<Complex>* dataPtr);
274  void putSliceDComplexV (StManArrayFile&, const Slicer&,
275  const Array<DComplex>* dataPtr);
276  void putSliceStringV (StManArrayFile&, const Slicer&,
277  const Array<String>* dataPtr);
278  // </group>
279 
280 private:
281  Int64 fileOffset_p; //# offset of shape in StManArrayFile
282  uInt arrOffset_p; //# extra offset to the array
283  //# 0 = arrOffset and shape not known yet
284  IPosition shape_p; //# shape of the array
285 
286  // Get sliced data, i.e. get a section of an array.
287  // This function is used by getSliceXXXV to have common functionality
288  // in one function. It calls the given getVec function for each
289  // chunk of data. In this way the bulk of type-independent code
290  // is concentrated in getSliceData resulting in small
291  // type-dependent functions.
292  void getSliceData (StManArrayFile&, const Slicer& ns, void* value,
293  const IPosition& userArrayShape,
294  void (*getVec) (StManArrayFile&,
295  Int64, uInt, uInt, uInt, uInt,
296  void* dataPtr));
297 
298  // Get a (type-dependent) vector part of a slice.
299  // This function is called for each chunk by putSliceData.
300  // <group>
301  static void getVecBoolV (StManArrayFile&,
302  Int64 fileOffset, uInt arrayStart,
303  uInt length, uInt increment,
304  uInt valueIndex, void* value);
305  static void getVecuCharV (StManArrayFile&,
306  Int64 fileOffset, uInt arrayStart,
307  uInt length, uInt increment,
308  uInt valueIndex, void* value);
309  static void getVecShortV (StManArrayFile&,
310  Int64 fileOffset, uInt arrayStart,
311  uInt length, uInt increment,
312  uInt valueIndex, void* value);
313  static void getVecuShortV (StManArrayFile&,
314  Int64 fileOffset, uInt arrayStart,
315  uInt length, uInt increment,
316  uInt valueIndex, void* value);
317  static void getVecIntV (StManArrayFile&,
318  Int64 fileOffset, uInt arrayStart,
319  uInt length, uInt increment,
320  uInt valueIndex, void* value);
321  static void getVecuIntV (StManArrayFile&,
322  Int64 fileOffset, uInt arrayStart,
323  uInt length, uInt increment,
324  uInt valueIndex, void* value);
325  static void getVecfloatV (StManArrayFile&,
326  Int64 fileOffset, uInt arrayStart,
327  uInt length, uInt increment,
328  uInt valueIndex, void* value);
329  static void getVecdoubleV (StManArrayFile&,
330  Int64 fileOffset, uInt arrayStart,
331  uInt length, uInt increment,
332  uInt valueIndex, void* value);
333  static void getVecComplexV (StManArrayFile&,
334  Int64 fileOffset, uInt arrayStart,
335  uInt length, uInt increment,
336  uInt valueIndex, void* value);
337  static void getVecDComplexV (StManArrayFile&,
338  Int64 fileOffset, uInt arrayStart,
339  uInt length, uInt increment,
340  uInt valueIndex, void* value);
341  static void getVecStringV (StManArrayFile&,
342  Int64 fileOffset, uInt arrayStart,
343  uInt length, uInt increment,
344  uInt valueIndex, void* value);
345  // </group>
346 
347  // Put sliced data, i.e. put a section of an array.
348  // This function is used by putSlice to have common functionality
349  // in one function. It calls the given in putVec function for
350  // chunk of data. In this way the bulk of type-independent code
351  // is concentrated in putSliceData resulting in small
352  // type-dependent functions.
353  void putSliceData (StManArrayFile&, const Slicer& ns, const void* value,
354  const IPosition& userArrayShape,
355  void (*putVec) (StManArrayFile&,
356  Int64, uInt, uInt, uInt, uInt,
357  const void* dataPtr));
358 
359  // Put a (type-dependent) vector part of a slice.
360  // This function is called for each chunk by putSliceData.
361  // <group>
362  static void putVecBoolV (StManArrayFile&,
363  Int64 fileOffset, uInt arrayStart,
364  uInt length, uInt increment,
365  uInt valueIndex, const void* value);
366  static void putVecuCharV (StManArrayFile&,
367  Int64 fileOffset, uInt arrayStart,
368  uInt length, uInt increment,
369  uInt valueIndex, const void* value);
370  static void putVecShortV (StManArrayFile&,
371  Int64 fileOffset, uInt arrayStart,
372  uInt length, uInt increment,
373  uInt valueIndex, const void* value);
374  static void putVecuShortV (StManArrayFile&,
375  Int64 fileOffset, uInt arrayStart,
376  uInt length, uInt increment,
377  uInt valueIndex, const void* value);
378  static void putVecIntV (StManArrayFile&,
379  Int64 fileOffset, uInt arrayStart,
380  uInt length, uInt increment,
381  uInt valueIndex, const void* value);
382  static void putVecuIntV (StManArrayFile&,
383  Int64 fileOffset, uInt arrayStart,
384  uInt length, uInt increment,
385  uInt valueIndex, const void* value);
386  static void putVecfloatV (StManArrayFile&,
387  Int64 fileOffset, uInt arrayStart,
388  uInt length, uInt increment,
389  uInt valueIndex, const void* value);
390  static void putVecdoubleV (StManArrayFile&,
391  Int64 fileOffset, uInt arrayStart,
392  uInt length, uInt increment,
393  uInt valueIndex, const void* value);
394  static void putVecComplexV (StManArrayFile&,
395  Int64 fileOffset, uInt arrayStart,
396  uInt length, uInt increment,
397  uInt valueIndex, const void* value);
398  static void putVecDComplexV (StManArrayFile&,
399  Int64 fileOffset, uInt arrayStart,
400  uInt length, uInt increment,
401  uInt valueIndex, const void* value);
402  static void putVecStringV (StManArrayFile&,
403  Int64 fileOffset, uInt arrayStart,
404  uInt length, uInt increment,
405  uInt valueIndex, const void* value);
406  // </group>
407 
408  // Throw an exception if the shape of the given array and the table
409  // array (slice) are not equal.
410  void checkShape (const IPosition& userArrayShape,
411  const IPosition& tableArrayShape) const;
412 };
413 
414 
415 
416 
417 } //# NAMESPACE CASACORE - END
418 
419 #endif
void putArrayIntV(StManArrayFile &, const Array< Int > *dataPtr)
A Vector of integers, for indexing into Array<T> objects.
Definition: IPosition.h:119
void putSliceBoolV(StManArrayFile &, const Slicer &, const Array< Bool > *dataPtr)
Put a section of the array into the file at the offset held in this object.
long long Int64
Define the extra non-standard types used by Casacore (like proposed uSize, Size)
Definition: aipsxtype.h:38
void getArrayDComplexV(StManArrayFile &, Array< DComplex > *dataPtr)
void putSliceData(StManArrayFile &, const Slicer &ns, const void *value, const IPosition &userArrayShape, void(*putVec)(StManArrayFile &, Int64, uInt, uInt, uInt, uInt, const void *dataPtr))
Put sliced data, i.e.
void putSliceStringV(StManArrayFile &, const Slicer &, const Array< String > *dataPtr)
static void getVecShortV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, void *value)
void putArrayfloatV(StManArrayFile &, const Array< float > *dataPtr)
void getArrayShortV(StManArrayFile &, Array< Short > *dataPtr)
void copyData(StManArrayFile &ios, int dataType, const StIndArray &other)
Copy the data from another array.
void putSliceIntV(StManArrayFile &, const Slicer &, const Array< Int > *dataPtr)
void getShape(StManArrayFile &ios)
Read the shape if not read yet.
void putSliceuCharV(StManArrayFile &, const Slicer &, const Array< uChar > *dataPtr)
void getSliceuCharV(StManArrayFile &, const Slicer &, Array< uChar > *dataPtr)
void getSliceComplexV(StManArrayFile &, const Slicer &, Array< Complex > *dataPtr)
static void getVecuIntV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, void *value)
static void getVecuCharV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, void *value)
void getSliceIntV(StManArrayFile &, const Slicer &, Array< Int > *dataPtr)
void getSliceuIntV(StManArrayFile &, const Slicer &, Array< uInt > *dataPtr)
void getSlicefloatV(StManArrayFile &, const Slicer &, Array< float > *dataPtr)
Read/write indirect arrays.
Definition: StIndArray.h:141
void getArrayuCharV(StManArrayFile &, Array< uChar > *dataPtr)
void getArrayIntV(StManArrayFile &, Array< Int > *dataPtr)
Int64 fileOffset() const
Get the file offset.
Definition: StIndArray.h:162
void putArrayuIntV(StManArrayFile &, const Array< uInt > *dataPtr)
void getArrayuShortV(StManArrayFile &, Array< uShort > *dataPtr)
static void putVecIntV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, const void *value)
static void getVecBoolV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, void *value)
Get a (type-dependent) vector part of a slice.
void putArraydoubleV(StManArrayFile &, const Array< double > *dataPtr)
Bool setShape(StManArrayFile &, int dataType, const IPosition &shape)
Set the shape and allocate the array in the file.
void checkShape(const IPosition &userArrayShape, const IPosition &tableArrayShape) const
Throw an exception if the shape of the given array and the table array (slice) are not equal...
const IPosition & shape() const
Get the shape.
Definition: StIndArray.h:158
void putSliceShortV(StManArrayFile &, const Slicer &, const Array< Short > *dataPtr)
void putSlicefloatV(StManArrayFile &, const Slicer &, const Array< float > *dataPtr)
static void putVecdoubleV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, const void *value)
void putSlicedoubleV(StManArrayFile &, const Slicer &, const Array< double > *dataPtr)
void getArrayComplexV(StManArrayFile &, Array< Complex > *dataPtr)
static void putVecuIntV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, const void *value)
void putArrayuCharV(StManArrayFile &, const Array< uChar > *dataPtr)
void getArrayStringV(StManArrayFile &, Array< String > *dataPtr)
void putArrayDComplexV(StManArrayFile &, const Array< DComplex > *dataPtr)
static void putVecBoolV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, const void *value)
Put a (type-dependent) vector part of a slice.
static void putVecuShortV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, const void *value)
void getSliceData(StManArrayFile &, const Slicer &ns, void *value, const IPosition &userArrayShape, void(*getVec)(StManArrayFile &, Int64, uInt, uInt, uInt, uInt, void *dataPtr))
Get sliced data, i.e.
LatticeExprNode length(const LatticeExprNode &expr, const LatticeExprNode &axis)
2-argument function to get the length of an axis.
void getSliceDComplexV(StManArrayFile &, const Slicer &, Array< DComplex > *dataPtr)
static void putVecDComplexV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, const void *value)
void incrementRefCount(StManArrayFile &ios)
Increment the reference count.
void putSliceComplexV(StManArrayFile &, const Slicer &, const Array< Complex > *dataPtr)
static void getVecdoubleV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, void *value)
bool Bool
Define the standard types used by Casacore.
Definition: aipstype.h:39
void putArrayBoolV(StManArrayFile &, const Array< Bool > *dataPtr)
Put an array value into the file at the offset held in this object.
void getSliceShortV(StManArrayFile &, const Slicer &, Array< Short > *dataPtr)
static void putVecStringV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, const void *value)
static void putVecComplexV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, const void *value)
void putArrayStringV(StManArrayFile &, const Array< String > *dataPtr)
void putSliceDComplexV(StManArrayFile &, const Slicer &, const Array< DComplex > *dataPtr)
Specify which elements to extract from an n-dimensional array.
Definition: Slicer.h:275
void getSliceBoolV(StManArrayFile &, const Slicer &, Array< Bool > *dataPtr)
Get a section of the array from the file at the offset held in this object.
void decrementRefCount(StManArrayFile &ios)
Decrement the reference count.
void getArrayBoolV(StManArrayFile &, Array< Bool > *dataPtr)
Get an array value from the file at the offset held in this object.
static void putVecShortV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, const void *value)
void getArrayuIntV(StManArrayFile &, Array< uInt > *dataPtr)
void getSliceStringV(StManArrayFile &, const Slicer &, Array< String > *dataPtr)
StIndArray & operator=(const StIndArray &)
Assignment.
void putArrayComplexV(StManArrayFile &, const Array< Complex > *dataPtr)
void getSliceuShortV(StManArrayFile &, const Slicer &, Array< uShort > *dataPtr)
static void putVecuCharV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, const void *value)
void getArrayfloatV(StManArrayFile &, Array< float > *dataPtr)
static void getVecIntV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, void *value)
static void getVecStringV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, void *value)
static void getVecuShortV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, void *value)
void getArraydoubleV(StManArrayFile &, Array< double > *dataPtr)
StIndArray(Int64 fileOffset)
Construct the object with the given file offset.
void putSliceuShortV(StManArrayFile &, const Slicer &, const Array< uShort > *dataPtr)
static void getVecfloatV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, void *value)
void putSliceuIntV(StManArrayFile &, const Slicer &, const Array< uInt > *dataPtr)
Read/write array in external format for a storage manager.
Definition: StArrayFile.h:129
uInt refCount(StManArrayFile &ios)
Get the reference count.
static void putVecfloatV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, const void *value)
static void getVecComplexV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, void *value)
static void getVecDComplexV(StManArrayFile &, Int64 fileOffset, uInt arrayStart, uInt length, uInt increment, uInt valueIndex, void *value)
this file contains all the compiler specific defines
Definition: mainpage.dox:28
void putArrayShortV(StManArrayFile &, const Array< Short > *dataPtr)
unsigned int uInt
Definition: aipstype.h:48
void getSlicedoubleV(StManArrayFile &, const Slicer &, Array< double > *dataPtr)
void putArrayuShortV(StManArrayFile &, const Array< uShort > *dataPtr)