Loading...
Searching...
No Matches
StManColumn.h
Go to the documentation of this file.
//# StManColumn.h: Base storage manager column class
//# Copyright (C) 1994,1995,1996,1998,2002
//# Associated Universities, Inc. Washington DC, USA.
//#
//# This library is free software; you can redistribute it and/or modify it
//# under the terms of the GNU Library General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or (at your
//# option) any later version.
//#
//# This library is distributed in the hope that it will be useful, but WITHOUT
//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
//# License for more details.
//#
//# You should have received a copy of the GNU Library General Public License
//# along with this library; if not, write to the Free Software Foundation,
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//# Internet email: casa-feedback@nrao.edu.
//# Postal address: AIPS++ Project Office
//# National Radio Astronomy Observatory
//# 520 Edgemont Road
//# Charlottesville, VA 22903-2475 USA
#ifndef TABLES_STMANCOLUMN_H
#define TABLES_STMANCOLUMN_H
//# Includes
#include <casacore/casa/aips.h>
#include <casacore/tables/DataMan/StManColumnBase.h>
#include <casacore/casa/Arrays/IPosition.h>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
// <summary>
// Base table column storage manager class
// </summary>
// <use visibility=local>
// <reviewed reviewer="Gareth Hunt" date="94Nov17" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> DataManagerColumn
// </prerequisite>
// <etymology>
// StManColumn handles a column for a storage manager.
// </etymology>
// <synopsis>
// StManColumn is the old storage manager base class which has been replaced
// by StManColumnBase.
// However, the class still exists for backward compatibility for external storage
// managers (such as LofarStMan) that do not derive from StManColumnBase yet.
// It also maps the new get/put functions taking a rownr_t to the old
// functions taking a uInt rownr.
// </synopsis>
// <motivation>
// Provide backward compatibility for external storage managers.
// </motivation>
// <todo asof="$DATE:$">
//# A List of bugs, limitations, extensions or planned refinements.
// </todo>
class StManColumn : public StManColumnBase
{
public:
// Default constructor.
StManColumn (int dataType)
: StManColumnBase (dataType)
{}
virtual ~StManColumn();
// The object cannot be copied.
StManColumn (const StManColumn&) = delete;
// The object cannot be assigned to.
StManColumn& operator= (const StManColumn&) = delete;
// Set the shape of an (variable-shaped) array in the given row.
// By default it throws a "not possible" exception.
virtual void setShape (rownr_t rownr, const IPosition& shape);
virtual void setShape (uInt rownr, const IPosition& shape);
// Set the shape and tile shape of an (variable-shaped) array
// in the given row.
// By default it ignores the tile shape (thus only sets the shape).
virtual void setShapeTiled (rownr_t rownr, const IPosition& shape,
const IPosition& tileShape);
virtual void setShapeTiled (uInt rownr, const IPosition& shape,
const IPosition& tileShape);
// Is the value shape defined in the given row?
// By default it returns True.
virtual Bool isShapeDefined (rownr_t rownr);
virtual Bool isShapeDefined (uInt rownr);
// Get the dimensionality of the item in the given row.
// By default it returns shape(rownr).nelements().
virtual uInt ndim (rownr_t rownr);
virtual uInt ndim (uInt rownr);
// Get the shape of the item in the given row.
// By default it returns a zero-length IPosition (for a scalar value).
virtual IPosition shape (rownr_t rownr);
virtual IPosition shape (uInt rownr);
// Get the tile shape of the item in the given row.
// By default it returns a zero-length IPosition.
virtual IPosition tileShape (rownr_t rownr);
virtual IPosition tileShape (uInt rownr);
// Get the scalar value in the given row.
// <group>
virtual void getBool (rownr_t rownr, Bool* dataPtr);
virtual void getuChar (rownr_t rownr, uChar* dataPtr);
virtual void getShort (rownr_t rownr, Short* dataPtr);
virtual void getuShort (rownr_t rownr, uShort* dataPtr);
virtual void getInt (rownr_t rownr, Int* dataPtr);
virtual void getuInt (rownr_t rownr, uInt* dataPtr);
virtual void getfloat (rownr_t rownr, float* dataPtr);
virtual void getdouble (rownr_t rownr, double* dataPtr);
virtual void getComplex (rownr_t rownr, Complex* dataPtr);
virtual void getDComplex (rownr_t rownr, DComplex* dataPtr);
virtual void getString (rownr_t rownr, String* dataPtr);
// </group>
// Put the scalar value in the given row.
// <group>
virtual void putBool (rownr_t rownr, const Bool* dataPtr);
virtual void putuChar (rownr_t rownr, const uChar* dataPtr);
virtual void putShort (rownr_t rownr, const Short* dataPtr);
virtual void putuShort (rownr_t rownr, const uShort* dataPtr);
virtual void putInt (rownr_t rownr, const Int* dataPtr);
virtual void putuInt (rownr_t rownr, const uInt* dataPtr);
virtual void putfloat (rownr_t rownr, const float* dataPtr);
virtual void putdouble (rownr_t rownr, const double* dataPtr);
virtual void putComplex (rownr_t rownr, const Complex* dataPtr);
virtual void putDComplex (rownr_t rownr, const DComplex* dataPtr);
virtual void putString (rownr_t rownr, const String* dataPtr);
// </group>
// Get all scalar values in the column.
// The argument dataPtr is in fact a Vector<T>&, but an ArrayBase&
// is needed to be generic.
// The vector pointed to by dataPtr has to have the correct length
// (which is guaranteed by the ScalarColumn getColumn function).
// The default implementation calls the appropriate getScalarColumnXXV.
virtual void getScalarColumnV (ArrayBase& dataPtr);
// Put all scalar values in the column.
// The argument dataPtr is in fact a const Vector<T>&, but a const ArrayBase&
// is needed to be generic.
// The vector pointed to by dataPtr has to have the correct length
// (which is guaranteed by the ScalarColumn putColumn function).
// The default implementation calls the appropriate putScalarColumnXXV.
virtual void putScalarColumnV (const ArrayBase& dataPtr);
// Get some scalar values in the column.
// The argument dataPtr is in fact a Vector<T>&, but an ArrayBase&
// is needed to be generic.
// The vector pointed to by dataPtr has to have the correct length
// (which is guaranteed by the ScalarColumn getColumn function).
// The default implementation calls the appropriate getScalarColumnCellsXXV.
virtual void getScalarColumnCellsV (const RefRows& rownrs,
ArrayBase& dataPtr);
// Put some scalar values in the column.
// The argument dataPtr is in fact a const Vector<T>&, but a const ArrayBase&
// is needed to be generic.
// The vector pointed to by dataPtr has to have the correct length
// (which is guaranteed by the ScalarColumn getColumn function).
// The default implementation calls the appropriate putScalarColumnCellsXXV.
virtual void putScalarColumnCellsV (const RefRows& rownrs,
const ArrayBase& dataPtr);
// Get the array value in the given row.
// The argument dataPtr is in fact an Array<T>&, but a ArrayBase&
// is needed to be generic.
// The array pointed to by dataPtr has to have the correct shape
// (which is guaranteed by the ArrayColumn get function).
// The default implementation calls the appropriate getArrayXXV.
virtual void getArrayV (rownr_t rownr, ArrayBase& dataPtr);
// Put the array value into the given row.
// The argument dataPtr is in fact a const Array<T>&, but a const ArrayBase&
// is needed to be generic.
// The array pointed to by dataPtr has to have the correct shape
// (which is guaranteed by the ArrayColumn put function).
// The default implementation calls the appropriate putArrayXXV.
virtual void putArrayV (rownr_t rownr, const ArrayBase& dataPtr);
// Get all array values in the column.
// The argument dataPtr is in fact an Array<T>&, but a ArrayBase&
// is needed to be generic.
// The vector pointed to by dataPtr has to have the correct length
// (which is guaranteed by the ArrayColumn getColumn function).
// The default implementation calls the appropriate getArrayColumnXXV.
virtual void getArrayColumnV (ArrayBase& dataPtr);
// Put all array values in the column.
// The argument dataPtr is in fact a const Array<T>&, but a const ArrayBase&
// is needed to be generic.
// The vector pointed to by dataPtr has to have the correct length
// (which is guaranteed by the ArrayColumn putColumn function).
// The default implementation calls the appropriate putArrayColumnXXV.
virtual void putArrayColumnV (const ArrayBase& dataPtr);
// Get some array values in the column.
// The argument dataPtr is in fact an Array<T>&, but a ArrayBase&
// is needed to be generic.
// The vector pointed to by dataPtr has to have the correct length
// (which is guaranteed by the ArrayColumn getColumn function).
// The default implementation calls the appropriate getArrayColumnCellsXXV.
virtual void getArrayColumnCellsV (const RefRows& rownrs,
ArrayBase& dataPtr);
// Put some array values in the column.
// The argument dataPtr is in fact an const Array<T>&, but a const ArrayBase&
// is needed to be generic.
// The vector pointed to by dataPtr has to have the correct length
// (which is guaranteed by the ArrayColumn getColumn function).
// The default implementation calls the appropriate putArrayColumnCellsXXV.
virtual void putArrayColumnCellsV (const RefRows& rownrs,
const ArrayBase& dataPtr);
// Get a section of the array in the given row.
// The argument dataPtr is in fact an Array<T>&, but a ArrayBase&
// is needed to be generic.
// The array pointed to by dataPtr has to have the correct shape
// (which is guaranteed by the ArrayColumn getSlice function).
// The default implementation calls the appropriate getSliceXXV.
virtual void getSliceV (rownr_t rownr, const Slicer& slicer,
ArrayBase& dataPtr);
// Put into a section of the array in the given row.
// The argument dataPtr is in fact a const Array<T>&, but a const ArrayBase&
// is needed to be generic.
// The array pointed to by dataPtr has to have the correct shape
// (which is guaranteed by the ArrayColumn putSlice function).
// The default implementation calls the appropriate putSliceXXV.
virtual void putSliceV (rownr_t rownr, const Slicer& slicer,
const ArrayBase& dataPtr);
// Get a section of all arrays in the column.
// The argument dataPtr is in fact an Array<T>&, but a ArrayBase&
// is needed to be generic.
// The array pointed to by dataPtr has to have the correct shape
// (which is guaranteed by the ArrayColumn getColumn function).
// The default implementation calls the appropriate getColumnSliceXXV.
virtual void getColumnSliceV (const Slicer& slicer, ArrayBase& dataPtr);
// Put into a section of all arrays in the column.
// The argument dataPtr is in fact a const Array<T>&, but a const ArrayBase&
// is needed to be generic.
// The array pointed to by dataPtr has to have the correct shape
// (which is guaranteed by the ArrayColumn putColumn function).
// The default implementation calls the appropriate putColumnSliceXXV.
virtual void putColumnSliceV (const Slicer& slicer, const ArrayBase& dataPtr);
// Get a section of some arrays in the column.
// The argument dataPtr is in fact an Array<T>&, but a ArrayBase&
// is needed to be generic.
// The array pointed to by dataPtr has to have the correct shape
// (which is guaranteed by the ArrayColumn getColumn function).
// The default implementation calls the appropriate getColumnSliceCellsXXV.
virtual void getColumnSliceCellsV (const RefRows& rownrs,
const Slicer& slicer, ArrayBase& dataPtr);
// Put into a section of some arrays in the column.
// The argument dataPtr is in fact a const Array<T>&, but a const ArrayBase&
// is needed to be generic.
// The array pointed to by dataPtr has to have the correct shape
// (which is guaranteed by the ArrayColumn putColumn function).
// The default implementation calls the appropriate putColumnSliceCellsXXV.
virtual void putColumnSliceCellsV (const RefRows& rownrs,
const Slicer& slicer,
const ArrayBase& dataPtr);
private:
// Throw an "invalid operation" exception for the default
// implementation of getArray.
void throwInvalidOp(const String &op) const;
protected:
// Get the scalar value in the given row.
// <group>
virtual void getBoolV (uInt rownr, Bool* dataPtr);
virtual void getuCharV (uInt rownr, uChar* dataPtr);
virtual void getShortV (uInt rownr, Short* dataPtr);
virtual void getuShortV (uInt rownr, uShort* dataPtr);
virtual void getIntV (uInt rownr, Int* dataPtr);
virtual void getuIntV (uInt rownr, uInt* dataPtr);
virtual void getfloatV (uInt rownr, float* dataPtr);
virtual void getdoubleV (uInt rownr, double* dataPtr);
virtual void getComplexV (uInt rownr, Complex* dataPtr);
virtual void getDComplexV (uInt rownr, DComplex* dataPtr);
virtual void getStringV (uInt rownr, String* dataPtr);
// </group>
// Put the scalar value in the given row.
// <group>
virtual void putBoolV (uInt rownr, const Bool* dataPtr);
virtual void putuCharV (uInt rownr, const uChar* dataPtr);
virtual void putShortV (uInt rownr, const Short* dataPtr);
virtual void putuShortV (uInt rownr, const uShort* dataPtr);
virtual void putIntV (uInt rownr, const Int* dataPtr);
virtual void putuIntV (uInt rownr, const uInt* dataPtr);
virtual void putfloatV (uInt rownr, const float* dataPtr);
virtual void putdoubleV (uInt rownr, const double* dataPtr);
virtual void putComplexV (uInt rownr, const Complex* dataPtr);
virtual void putDComplexV (uInt rownr, const DComplex* dataPtr);
virtual void putStringV (uInt rownr, const String* dataPtr);
// </group>
// Get the scalar values in the entire column.
// The buffer pointed to by dataPtr has to have the correct length.
// (which is guaranteed by the ScalarColumn getColumn function).
// The default implementations calls DataManagerColumn::getScalarColumnBase.
// <group>
virtual void getScalarColumnBoolV (Vector<Bool>* dataPtr);
virtual void getScalarColumnuCharV (Vector<uChar>* dataPtr);
virtual void getScalarColumnShortV (Vector<Short>* dataPtr);
virtual void getScalarColumnuShortV (Vector<uShort>* dataPtr);
virtual void getScalarColumnIntV (Vector<Int>* dataPtr);
virtual void getScalarColumnuIntV (Vector<uInt>* dataPtr);
virtual void getScalarColumnInt64V (Vector<Int64>* dataPtr);
virtual void getScalarColumnfloatV (Vector<float>* dataPtr);
virtual void getScalarColumndoubleV (Vector<double>* dataPtr);
virtual void getScalarColumnComplexV (Vector<Complex>* dataPtr);
virtual void getScalarColumnDComplexV (Vector<DComplex>* dataPtr);
virtual void getScalarColumnStringV (Vector<String>* dataPtr);
// </group>
// Put the scalar values into the entire column.
// The buffer pointed to by dataPtr has to have the correct length.
// (which is guaranteed by the ScalarColumn putColumn function).
// The default implementations calls DataManagerColumn::putScalarColumnBase.
// <group>
virtual void putScalarColumnBoolV (const Vector<Bool>* dataPtr);
virtual void putScalarColumnuCharV (const Vector<uChar>* dataPtr);
virtual void putScalarColumnShortV (const Vector<Short>* dataPtr);
virtual void putScalarColumnuShortV (const Vector<uShort>* dataPtr);
virtual void putScalarColumnIntV (const Vector<Int>* dataPtr);
virtual void putScalarColumnuIntV (const Vector<uInt>* dataPtr);
virtual void putScalarColumnInt64V (const Vector<Int64>* dataPtr);
virtual void putScalarColumnfloatV (const Vector<float>* dataPtr);
virtual void putScalarColumndoubleV (const Vector<double>* dataPtr);
virtual void putScalarColumnComplexV (const Vector<Complex>* dataPtr);
virtual void putScalarColumnDComplexV (const Vector<DComplex>* dataPtr);
virtual void putScalarColumnStringV (const Vector<String>* dataPtr);
// </group>
// Get the scalar values in some cells of the column.
// The buffer pointed to by dataPtr has to have the correct length.
// (which is guaranteed by the ScalarColumn getColumnCells function).
// The default implementations call DataManagerColumn::getScalarColumnCellsBase.
// <group>
virtual void getScalarColumnCellsBoolV (const RefRows& rownrs,
Vector<Bool>* dataPtr);
virtual void getScalarColumnCellsuCharV (const RefRows& rownrs,
Vector<uChar>* dataPtr);
virtual void getScalarColumnCellsShortV (const RefRows& rownrs,
Vector<Short>* dataPtr);
virtual void getScalarColumnCellsuShortV (const RefRows& rownrs,
Vector<uShort>* dataPtr);
virtual void getScalarColumnCellsIntV (const RefRows& rownrs,
Vector<Int>* dataPtr);
virtual void getScalarColumnCellsuIntV (const RefRows& rownrs,
Vector<uInt>* dataPtr);
virtual void getScalarColumnCellsInt64V (const RefRows& rownrs,
Vector<Int64>* dataPtr);
virtual void getScalarColumnCellsfloatV (const RefRows& rownrs,
Vector<float>* dataPtr);
virtual void getScalarColumnCellsdoubleV (const RefRows& rownrs,
Vector<double>* dataPtr);
virtual void getScalarColumnCellsComplexV (const RefRows& rownrs,
Vector<Complex>* dataPtr);
virtual void getScalarColumnCellsDComplexV (const RefRows& rownrs,
Vector<DComplex>* dataPtr);
virtual void getScalarColumnCellsStringV (const RefRows& rownrs,
Vector<String>* dataPtr);
// </group>
// Put the scalar values into some cells of the column.
// The buffer pointed to by dataPtr has to have the correct length.
// (which is guaranteed by the ScalarColumn putColumnCells function).
// The default implementations call DataManagerColumn::putScalarColumnCellsBase.
// <group>
virtual void putScalarColumnCellsBoolV (const RefRows& rownrs,
const Vector<Bool>* dataPtr);
virtual void putScalarColumnCellsuCharV (const RefRows& rownrs,
const Vector<uChar>* dataPtr);
virtual void putScalarColumnCellsShortV (const RefRows& rownrs,
const Vector<Short>* dataPtr);
virtual void putScalarColumnCellsuShortV (const RefRows& rownrs,
const Vector<uShort>* dataPtr);
virtual void putScalarColumnCellsIntV (const RefRows& rownrs,
const Vector<Int>* dataPtr);
virtual void putScalarColumnCellsuIntV (const RefRows& rownrs,
const Vector<uInt>* dataPtr);
virtual void putScalarColumnCellsInt64V (const RefRows& rownrs,
const Vector<Int64>* dataPtr);
virtual void putScalarColumnCellsfloatV (const RefRows& rownrs,
const Vector<float>* dataPtr);
virtual void putScalarColumnCellsdoubleV (const RefRows& rownrs,
const Vector<double>* dataPtr);
virtual void putScalarColumnCellsComplexV (const RefRows& rownrs,
const Vector<Complex>* dataPtr);
virtual void putScalarColumnCellsDComplexV (const RefRows& rownrs,
const Vector<DComplex>* dataPtr);
virtual void putScalarColumnCellsStringV (const RefRows& rownrs,
const Vector<String>* dataPtr);
// </group>
// Get the array value in the given row.
// The array pointed to by dataPtr has to have the correct length
// (which is guaranteed by the ArrayColumn get function).
// The default implementations throw an exception.
// <group>
virtual void getArrayBoolV (uInt rownr, Array<Bool>* dataPtr);
virtual void getArrayuCharV (uInt rownr, Array<uChar>* dataPtr);
virtual void getArrayShortV (uInt rownr, Array<Short>* dataPtr);
virtual void getArrayuShortV (uInt rownr, Array<uShort>* dataPtr);
virtual void getArrayIntV (uInt rownr, Array<Int>* dataPtr);
virtual void getArrayuIntV (uInt rownr, Array<uInt>* dataPtr);
virtual void getArrayInt64V (uInt rownr, Array<Int64>* dataPtr);
virtual void getArrayfloatV (uInt rownr, Array<float>* dataPtr);
virtual void getArraydoubleV (uInt rownr, Array<double>* dataPtr);
virtual void getArrayComplexV (uInt rownr, Array<Complex>* dataPtr);
virtual void getArrayDComplexV (uInt rownr, Array<DComplex>* dataPtr);
virtual void getArrayStringV (uInt rownr, Array<String>* dataPtr);
// </group>
// Put the array value into the given row.
// The buffer pointed to by dataPtr has to have the correct length
// (which is guaranteed by the ArrayColumn put function).
// The default implementations throw an exception.
// <group>
virtual void putArrayBoolV (uInt rownr,
const Array<Bool>* dataPtr);
virtual void putArrayuCharV (uInt rownr,
const Array<uChar>* dataPtr);
virtual void putArrayShortV (uInt rownr,
const Array<Short>* dataPtr);
virtual void putArrayuShortV (uInt rownr,
const Array<uShort>* dataPtr);
virtual void putArrayIntV (uInt rownr,
const Array<Int>* dataPtr);
virtual void putArrayuIntV (uInt rownr,
const Array<uInt>* dataPtr);
virtual void putArrayInt64V (uInt rownr,
const Array<Int64>* dataPtr);
virtual void putArrayfloatV (uInt rownr,
const Array<float>* dataPtr);
virtual void putArraydoubleV (uInt rownr,
const Array<double>* dataPtr);
virtual void putArrayComplexV (uInt rownr,
const Array<Complex>* dataPtr);
virtual void putArrayDComplexV (uInt rownr,
const Array<DComplex>* dataPtr);
virtual void putArrayStringV (uInt rownr,
const Array<String>* dataPtr);
// </group>
// Get the array values in the entire column.
// The buffer pointed to by dataPtr has to have the correct length.
// (which is guaranteed by the ArrayColumn getColumn function).
// The default implementations call DataManagerColumn::getArrayColumnBase.
// <group>
virtual void getArrayColumnBoolV (Array<Bool>* dataPtr);
virtual void getArrayColumnuCharV (Array<uChar>* dataPtr);
virtual void getArrayColumnShortV (Array<Short>* dataPtr);
virtual void getArrayColumnuShortV (Array<uShort>* dataPtr);
virtual void getArrayColumnIntV (Array<Int>* dataPtr);
virtual void getArrayColumnuIntV (Array<uInt>* dataPtr);
virtual void getArrayColumnInt64V (Array<Int64>* dataPtr);
virtual void getArrayColumnfloatV (Array<float>* dataPtr);
virtual void getArrayColumndoubleV (Array<double>* dataPtr);
virtual void getArrayColumnComplexV (Array<Complex>* dataPtr);
virtual void getArrayColumnDComplexV (Array<DComplex>* dataPtr);
virtual void getArrayColumnStringV (Array<String>* dataPtr);
// </group>
// Put the array values into the entire column.
// The buffer pointed to by dataPtr has to have the correct length.
// (which is guaranteed by the ArrayColumn putColumn function).
// The default implementations call DataManagerColumn::putArrayColumnBase.
// <group>
virtual void putArrayColumnBoolV (const Array<Bool>* dataPtr);
virtual void putArrayColumnuCharV (const Array<uChar>* dataPtr);
virtual void putArrayColumnShortV (const Array<Short>* dataPtr);
virtual void putArrayColumnuShortV (const Array<uShort>* dataPtr);
virtual void putArrayColumnIntV (const Array<Int>* dataPtr);
virtual void putArrayColumnuIntV (const Array<uInt>* dataPtr);
virtual void putArrayColumnInt64V (const Array<Int64>* dataPtr);
virtual void putArrayColumnfloatV (const Array<float>* dataPtr);
virtual void putArrayColumndoubleV (const Array<double>* dataPtr);
virtual void putArrayColumnComplexV (const Array<Complex>* dataPtr);
virtual void putArrayColumnDComplexV (const Array<DComplex>* dataPtr);
virtual void putArrayColumnStringV (const Array<String>* dataPtr);
// </group>
// Get the array values in some cells of the column.
// The buffer pointed to by dataPtr has to have the correct length.
// (which is guaranteed by the ArrayColumn getColumnCells function).
// The default implementations call DataManagerColumn::getArrayColumnCellsBase.
// <group>
virtual void getArrayColumnCellsBoolV (const RefRows& rownrs,
Array<Bool>* dataPtr);
virtual void getArrayColumnCellsuCharV (const RefRows& rownrs,
Array<uChar>* dataPtr);
virtual void getArrayColumnCellsShortV (const RefRows& rownrs,
Array<Short>* dataPtr);
virtual void getArrayColumnCellsuShortV (const RefRows& rownrs,
Array<uShort>* dataPtr);
virtual void getArrayColumnCellsIntV (const RefRows& rownrs,
Array<Int>* dataPtr);
virtual void getArrayColumnCellsuIntV (const RefRows& rownrs,
Array<uInt>* dataPtr);
virtual void getArrayColumnCellsInt64V (const RefRows& rownrs,
Array<Int64>* dataPtr);
virtual void getArrayColumnCellsfloatV (const RefRows& rownrs,
Array<float>* dataPtr);
virtual void getArrayColumnCellsdoubleV (const RefRows& rownrs,
Array<double>* dataPtr);
virtual void getArrayColumnCellsComplexV (const RefRows& rownrs,
Array<Complex>* dataPtr);
virtual void getArrayColumnCellsDComplexV (const RefRows& rownrs,
Array<DComplex>* dataPtr);
virtual void getArrayColumnCellsStringV (const RefRows& rownrs,
Array<String>* dataPtr);
// </group>
// Put the array values into some cells of the column.
// The buffer pointed to by dataPtr has to have the correct length.
// (which is guaranteed by the ArrayColumn putColumnCells function).
// The default implementations call DataManagerColumn::putArrayColumnCellsBase.
// <group>
virtual void putArrayColumnCellsBoolV (const RefRows& rownrs,
const Array<Bool>* dataPtr);
virtual void putArrayColumnCellsuCharV (const RefRows& rownrs,
const Array<uChar>* dataPtr);
virtual void putArrayColumnCellsShortV (const RefRows& rownrs,
const Array<Short>* dataPtr);
virtual void putArrayColumnCellsuShortV (const RefRows& rownrs,
const Array<uShort>* dataPtr);
virtual void putArrayColumnCellsIntV (const RefRows& rownrs,
const Array<Int>* dataPtr);
virtual void putArrayColumnCellsuIntV (const RefRows& rownrs,
const Array<uInt>* dataPtr);
virtual void putArrayColumnCellsInt64V (const RefRows& rownrs,
const Array<Int64>* dataPtr);
virtual void putArrayColumnCellsfloatV (const RefRows& rownrs,
const Array<float>* dataPtr);
virtual void putArrayColumnCellsdoubleV (const RefRows& rownrs,
const Array<double>* dataPtr);
virtual void putArrayColumnCellsComplexV (const RefRows& rownrs,
const Array<Complex>* dataPtr);
virtual void putArrayColumnCellsDComplexV (const RefRows& rownrs,
const Array<DComplex>* dataPtr);
virtual void putArrayColumnCellsStringV (const RefRows& rownrs,
const Array<String>* dataPtr);
// </group>
// Get the array value in the given row.
// The array pointed to by dataPtr has to have the correct length
// (which is guaranteed by the ArrayColumn getSlice function).
// The default implementations call DataManagerColumn::getSliceBase.
// <group>
virtual void getSliceBoolV (uInt rownr, const Slicer& ns,
Array<Bool>* dataPtr);
virtual void getSliceuCharV (uInt rownr, const Slicer& ns,
Array<uChar>* dataPtr);
virtual void getSliceShortV (uInt rownr, const Slicer& ns,
Array<Short>* dataPtr);
virtual void getSliceuShortV (uInt rownr, const Slicer& ns,
Array<uShort>* dataPtr);
virtual void getSliceIntV (uInt rownr, const Slicer& ns,
Array<Int>* dataPtr);
virtual void getSliceuIntV (uInt rownr, const Slicer& ns,
Array<uInt>* dataPtr);
virtual void getSliceInt64V (uInt rownr, const Slicer& ns,
Array<Int64>* dataPtr);
virtual void getSlicefloatV (uInt rownr, const Slicer& ns,
Array<float>* dataPtr);
virtual void getSlicedoubleV (uInt rownr, const Slicer& ns,
Array<double>* dataPtr);
virtual void getSliceComplexV (uInt rownr, const Slicer& ns,
Array<Complex>* dataPtr);
virtual void getSliceDComplexV (uInt rownr, const Slicer& ns,
Array<DComplex>* dataPtr);
virtual void getSliceStringV (uInt rownr, const Slicer& ns,
Array<String>* dataPtr);
// </group>
// Put the array value into the given row.
// The buffer pointed to by dataPtr has to have the correct length
// (which is guaranteed by the ArrayColumn putSlice function).
// The default implementations call DataManagerColumn::putSliceBase.
// <group>
virtual void putSliceBoolV (uInt rownr, const Slicer& ns,
const Array<Bool>* dataPtr);
virtual void putSliceuCharV (uInt rownr, const Slicer& ns,
const Array<uChar>* dataPtr);
virtual void putSliceShortV (uInt rownr, const Slicer& ns,
const Array<Short>* dataPtr);
virtual void putSliceuShortV (uInt rownr, const Slicer& ns,
const Array<uShort>* dataPtr);
virtual void putSliceIntV (uInt rownr, const Slicer& ns,
const Array<Int>* dataPtr);
virtual void putSliceuIntV (uInt rownr, const Slicer& ns,
const Array<uInt>* dataPtr);
virtual void putSliceInt64V (uInt rownr, const Slicer& ns,
const Array<Int64>* dataPtr);
virtual void putSlicefloatV (uInt rownr, const Slicer& ns,
const Array<float>* dataPtr);
virtual void putSlicedoubleV (uInt rownr, const Slicer& ns,
const Array<double>* dataPtr);
virtual void putSliceComplexV (uInt rownr, const Slicer& ns,
const Array<Complex>* dataPtr);
virtual void putSliceDComplexV (uInt rownr, const Slicer& ns,
const Array<DComplex>* dataPtr);
virtual void putSliceStringV (uInt rownr, const Slicer& ns,
const Array<String>* dataPtr);
// </group>
// Get the array values in the entire column.
// The buffer pointed to by dataPtr has to have the correct length.
// (which is guaranteed by the ArrayColumn getColumn function).
// The default implementations call DataManagerColumn::getColumnSliceBase.
// <group>
virtual void getColumnSliceBoolV (const Slicer& ns,
Array<Bool>* dataPtr);
virtual void getColumnSliceuCharV (const Slicer& ns,
Array<uChar>* dataPtr);
virtual void getColumnSliceShortV (const Slicer& ns,
Array<Short>* dataPtr);
virtual void getColumnSliceuShortV (const Slicer& ns,
Array<uShort>* dataPtr);
virtual void getColumnSliceIntV (const Slicer& ns,
Array<Int>* dataPtr);
virtual void getColumnSliceuIntV (const Slicer& ns,
Array<uInt>* dataPtr);
virtual void getColumnSliceInt64V (const Slicer& ns,
Array<Int64>* dataPtr);
virtual void getColumnSlicefloatV (const Slicer& ns,
Array<float>* dataPtr);
virtual void getColumnSlicedoubleV (const Slicer& ns,
Array<double>* dataPtr);
virtual void getColumnSliceComplexV (const Slicer& ns,
Array<Complex>* dataPtr);
virtual void getColumnSliceDComplexV (const Slicer& ns,
Array<DComplex>* dataPtr);
virtual void getColumnSliceStringV (const Slicer& ns,
Array<String>* dataPtr);
// </group>
// Put the array values into the entire column.
// The buffer pointed to by dataPtr has to have the correct length.
// (which is guaranteed by the ArrayColumn putColumn function).
// The default implementations call DataManagerColumn::putColumnSliceBase.
// <group>
virtual void putColumnSliceBoolV (const Slicer& ns,
const Array<Bool>* dataPtr);
virtual void putColumnSliceuCharV (const Slicer& ns,
const Array<uChar>* dataPtr);
virtual void putColumnSliceShortV (const Slicer& ns,
const Array<Short>* dataPtr);
virtual void putColumnSliceuShortV (const Slicer& ns,
const Array<uShort>* dataPtr);
virtual void putColumnSliceIntV (const Slicer& ns,
const Array<Int>* dataPtr);
virtual void putColumnSliceuIntV (const Slicer& ns,
const Array<uInt>* dataPtr);
virtual void putColumnSliceInt64V (const Slicer& ns,
const Array<Int64>* dataPtr);
virtual void putColumnSlicefloatV (const Slicer& ns,
const Array<float>* dataPtr);
virtual void putColumnSlicedoubleV (const Slicer& ns,
const Array<double>* dataPtr);
virtual void putColumnSliceComplexV (const Slicer& ns,
const Array<Complex>* dataPtr);
virtual void putColumnSliceDComplexV (const Slicer& ns,
const Array<DComplex>* dataPtr);
virtual void putColumnSliceStringV (const Slicer& ns,
const Array<String>* dataPtr);
// </group>
// Get the array values in some cells of the column.
// The buffer pointed to by dataPtr has to have the correct length.
// (which is guaranteed by the ArrayColumn getColumnCells function).
// The default implementations call DataManagerColumn::getColumnSliceCellsBase.
// <group>
virtual void getColumnSliceCellsBoolV (const RefRows& rownrs,
const Slicer& ns,
Array<Bool>* dataPtr);
virtual void getColumnSliceCellsuCharV (const RefRows& rownrs,
const Slicer& ns,
Array<uChar>* dataPtr);
virtual void getColumnSliceCellsShortV (const RefRows& rownrs,
const Slicer& ns,
Array<Short>* dataPtr);
virtual void getColumnSliceCellsuShortV (const RefRows& rownrs,
const Slicer& ns,
Array<uShort>* dataPtr);
virtual void getColumnSliceCellsIntV (const RefRows& rownrs,
const Slicer& ns,
Array<Int>* dataPtr);
virtual void getColumnSliceCellsuIntV (const RefRows& rownrs,
const Slicer& ns,
Array<uInt>* dataPtr);
virtual void getColumnSliceCellsInt64V (const RefRows& rownrs,
const Slicer& ns,
Array<Int64>* dataPtr);
virtual void getColumnSliceCellsfloatV (const RefRows& rownrs,
const Slicer& ns,
Array<float>* dataPtr);
virtual void getColumnSliceCellsdoubleV (const RefRows& rownrs,
const Slicer& ns,
Array<double>* dataPtr);
virtual void getColumnSliceCellsComplexV (const RefRows& rownrs,
const Slicer& ns,
Array<Complex>* dataPtr);
virtual void getColumnSliceCellsDComplexV (const RefRows& rownrs,
const Slicer& ns,
Array<DComplex>* dataPtr);
virtual void getColumnSliceCellsStringV (const RefRows& rownrs,
const Slicer& ns,
Array<String>* dataPtr);
// </group>
// Put the array values into some cells of the column.
// The buffer pointed to by dataPtr has to have the correct length.
// (which is guaranteed by the ArrayColumn putColumnSlice function).
// The default implementations call DataManagerColumn::putColumnSliceCellsBase.
// <group>
virtual void putColumnSliceCellsBoolV (const RefRows& rownrs,
const Slicer& ns,
const Array<Bool>* dataPtr);
virtual void putColumnSliceCellsuCharV (const RefRows& rownrs,
const Slicer& ns,
const Array<uChar>* dataPtr);
virtual void putColumnSliceCellsShortV (const RefRows& rownrs,
const Slicer& ns,
const Array<Short>* dataPtr);
virtual void putColumnSliceCellsuShortV (const RefRows& rownrs,
const Slicer& ns,
const Array<uShort>* dataPtr);
virtual void putColumnSliceCellsIntV (const RefRows& rownrs,
const Slicer& ns,
const Array<Int>* dataPtr);
virtual void putColumnSliceCellsuIntV (const RefRows& rownrs,
const Slicer& ns,
const Array<uInt>* dataPtr);
virtual void putColumnSliceCellsInt64V (const RefRows& rownrs,
const Slicer& ns,
const Array<Int64>* dataPtr);
virtual void putColumnSliceCellsfloatV (const RefRows& rownrs,
const Slicer& ns,
const Array<float>* dataPtr);
virtual void putColumnSliceCellsdoubleV (const RefRows& rownrs,
const Slicer& ns,
const Array<double>* dataPtr);
virtual void putColumnSliceCellsComplexV (const RefRows& rownrs,
const Slicer& ns,
const Array<Complex>* dataPtr);
virtual void putColumnSliceCellsDComplexV (const RefRows& rownrs,
const Slicer& ns,
const Array<DComplex>* dataPtr);
virtual void putColumnSliceCellsStringV (const RefRows& rownrs,
const Slicer& ns,
const Array<String>* dataPtr);
// </group>
};
} //# NAMESPACE CASACORE - END
#endif
casacore::ArrayBase
Non-templated base class for templated Array class.
Definition ArrayBase.h:71
casacore::Array
Definition Array.h:155
casacore::IPosition
Definition IPosition.h:117
casacore::RefRows
Definition RefRows.h:84
casacore::Slicer
Definition Slicer.h:287
casacore::StManColumnBase::dataType
virtual int dataType() const
Return the data type of the column.
casacore::StManColumnBase::StManColumnBase
StManColumnBase(int dataType)
Default constructor.
casacore::StManColumn::putArrayColumnCellsShortV
virtual void putArrayColumnCellsShortV(const RefRows &rownrs, const Array< Short > *dataPtr)
casacore::StManColumn::getArrayColumnuShortV
virtual void getArrayColumnuShortV(Array< uShort > *dataPtr)
casacore::StManColumn::putuIntV
virtual void putuIntV(uInt rownr, const uInt *dataPtr)
casacore::StManColumn::putSliceShortV
virtual void putSliceShortV(uInt rownr, const Slicer &ns, const Array< Short > *dataPtr)
casacore::StManColumn::putSliceV
virtual void putSliceV(rownr_t rownr, const Slicer &slicer, const ArrayBase &dataPtr)
Put into a section of the array in the given row.
casacore::StManColumn::getColumnSliceCellsuShortV
virtual void getColumnSliceCellsuShortV(const RefRows &rownrs, const Slicer &ns, Array< uShort > *dataPtr)
casacore::StManColumn::getScalarColumnDComplexV
virtual void getScalarColumnDComplexV(Vector< DComplex > *dataPtr)
casacore::StManColumn::getArrayColumnShortV
virtual void getArrayColumnShortV(Array< Short > *dataPtr)
casacore::StManColumn::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::StManColumn::ndim
virtual uInt ndim(uInt rownr)
casacore::StManColumn::putArrayBoolV
virtual void putArrayBoolV(uInt rownr, const Array< Bool > *dataPtr)
Put the array value into the given row.
casacore::StManColumn::getScalarColumnCellsuIntV
virtual void getScalarColumnCellsuIntV(const RefRows &rownrs, Vector< uInt > *dataPtr)
casacore::StManColumn::getArrayInt64V
virtual void getArrayInt64V(uInt rownr, Array< Int64 > *dataPtr)
casacore::StManColumn::isShapeDefined
virtual Bool isShapeDefined(uInt rownr)
casacore::StManColumn::getColumnSliceIntV
virtual void getColumnSliceIntV(const Slicer &ns, Array< Int > *dataPtr)
casacore::StManColumn::putScalarColumnCellsuShortV
virtual void putScalarColumnCellsuShortV(const RefRows &rownrs, const Vector< uShort > *dataPtr)
casacore::StManColumn::putSliceuShortV
virtual void putSliceuShortV(uInt rownr, const Slicer &ns, const Array< uShort > *dataPtr)
casacore::StManColumn::putScalarColumnCellsDComplexV
virtual void putScalarColumnCellsDComplexV(const RefRows &rownrs, const Vector< DComplex > *dataPtr)
casacore::StManColumn::getArrayColumnCellsV
virtual void getArrayColumnCellsV(const RefRows &rownrs, ArrayBase &dataPtr)
Get some array values in the column.
casacore::StManColumn::putColumnSliceCellsuIntV
virtual void putColumnSliceCellsuIntV(const RefRows &rownrs, const Slicer &ns, const Array< uInt > *dataPtr)
casacore::StManColumn::getScalarColumnCellsV
virtual void getScalarColumnCellsV(const RefRows &rownrs, ArrayBase &dataPtr)
Get some scalar values in the column.
casacore::StManColumn::getArrayColumnCellsInt64V
virtual void getArrayColumnCellsInt64V(const RefRows &rownrs, Array< Int64 > *dataPtr)
casacore::StManColumn::getSliceuShortV
virtual void getSliceuShortV(uInt rownr, const Slicer &ns, Array< uShort > *dataPtr)
casacore::StManColumn::getColumnSliceCellsInt64V
virtual void getColumnSliceCellsInt64V(const RefRows &rownrs, const Slicer &ns, Array< Int64 > *dataPtr)
casacore::StManColumn::putString
virtual void putString(rownr_t rownr, const String *dataPtr)
casacore::StManColumn::getuShortV
virtual void getuShortV(uInt rownr, uShort *dataPtr)
casacore::StManColumn::getScalarColumnCellsStringV
virtual void getScalarColumnCellsStringV(const RefRows &rownrs, Vector< String > *dataPtr)
casacore::StManColumn::getArrayBoolV
virtual void getArrayBoolV(uInt rownr, Array< Bool > *dataPtr)
Get the array value in the given row.
casacore::StManColumn::putScalarColumnCellsuIntV
virtual void putScalarColumnCellsuIntV(const RefRows &rownrs, const Vector< uInt > *dataPtr)
casacore::StManColumn::putSliceuIntV
virtual void putSliceuIntV(uInt rownr, const Slicer &ns, const Array< uInt > *dataPtr)
casacore::StManColumn::putArrayColumnDComplexV
virtual void putArrayColumnDComplexV(const Array< DComplex > *dataPtr)
casacore::StManColumn::putScalarColumnCellsfloatV
virtual void putScalarColumnCellsfloatV(const RefRows &rownrs, const Vector< float > *dataPtr)
casacore::StManColumn::putArrayColumnCellsV
virtual void putArrayColumnCellsV(const RefRows &rownrs, const ArrayBase &dataPtr)
Put some array values in the column.
casacore::StManColumn::getArrayColumnCellsBoolV
virtual void getArrayColumnCellsBoolV(const RefRows &rownrs, Array< Bool > *dataPtr)
Get the array values in some cells of the column.
casacore::StManColumn::getArrayColumnCellsuCharV
virtual void getArrayColumnCellsuCharV(const RefRows &rownrs, Array< uChar > *dataPtr)
casacore::StManColumn::putArrayColumnfloatV
virtual void putArrayColumnfloatV(const Array< float > *dataPtr)
casacore::StManColumn::getScalarColumnComplexV
virtual void getScalarColumnComplexV(Vector< Complex > *dataPtr)
casacore::StManColumn::getArrayColumnV
virtual void getArrayColumnV(ArrayBase &dataPtr)
Get all array values in the column.
casacore::StManColumn::getSliceIntV
virtual void getSliceIntV(uInt rownr, const Slicer &ns, Array< Int > *dataPtr)
casacore::StManColumn::putArrayColumnCellsfloatV
virtual void putArrayColumnCellsfloatV(const RefRows &rownrs, const Array< float > *dataPtr)
casacore::StManColumn::getColumnSliceBoolV
virtual void getColumnSliceBoolV(const Slicer &ns, Array< Bool > *dataPtr)
Get the array values in the entire column.
casacore::StManColumn::putColumnSliceV
virtual void putColumnSliceV(const Slicer &slicer, const ArrayBase &dataPtr)
Put into a section of all arrays in the column.
casacore::StManColumn::putArrayShortV
virtual void putArrayShortV(uInt rownr, const Array< Short > *dataPtr)
casacore::StManColumn::putdoubleV
virtual void putdoubleV(uInt rownr, const double *dataPtr)
casacore::StManColumn::getArrayColumnCellsfloatV
virtual void getArrayColumnCellsfloatV(const RefRows &rownrs, Array< float > *dataPtr)
casacore::StManColumn::putScalarColumnBoolV
virtual void putScalarColumnBoolV(const Vector< Bool > *dataPtr)
Put the scalar values into the entire column.
casacore::StManColumn::putuInt
virtual void putuInt(rownr_t rownr, const uInt *dataPtr)
casacore::StManColumn::putColumnSliceCellsDComplexV
virtual void putColumnSliceCellsDComplexV(const RefRows &rownrs, const Slicer &ns, const Array< DComplex > *dataPtr)
casacore::StManColumn::getString
virtual void getString(rownr_t rownr, String *dataPtr)
casacore::StManColumn::putColumnSliceCellsInt64V
virtual void putColumnSliceCellsInt64V(const RefRows &rownrs, const Slicer &ns, const Array< Int64 > *dataPtr)
casacore::StManColumn::putArrayColumnuShortV
virtual void putArrayColumnuShortV(const Array< uShort > *dataPtr)
casacore::StManColumn::getScalarColumndoubleV
virtual void getScalarColumndoubleV(Vector< double > *dataPtr)
casacore::StManColumn::putArrayColumnStringV
virtual void putArrayColumnStringV(const Array< String > *dataPtr)
casacore::StManColumn::getColumnSliceV
virtual void getColumnSliceV(const Slicer &slicer, ArrayBase &dataPtr)
Get a section of all arrays in the column.
casacore::StManColumn::getArrayDComplexV
virtual void getArrayDComplexV(uInt rownr, Array< DComplex > *dataPtr)
casacore::StManColumn::putColumnSliceCellsuCharV
virtual void putColumnSliceCellsuCharV(const RefRows &rownrs, const Slicer &ns, const Array< uChar > *dataPtr)
casacore::StManColumn::putArrayStringV
virtual void putArrayStringV(uInt rownr, const Array< String > *dataPtr)
casacore::StManColumn::putColumnSliceCellsuShortV
virtual void putColumnSliceCellsuShortV(const RefRows &rownrs, const Slicer &ns, const Array< uShort > *dataPtr)
casacore::StManColumn::getScalarColumnCellsIntV
virtual void getScalarColumnCellsIntV(const RefRows &rownrs, Vector< Int > *dataPtr)
casacore::StManColumn::putArrayColumnCellsuCharV
virtual void putArrayColumnCellsuCharV(const RefRows &rownrs, const Array< uChar > *dataPtr)
casacore::StManColumn::getScalarColumnV
virtual void getScalarColumnV(ArrayBase &dataPtr)
Get all scalar values in the column.
casacore::StManColumn::putScalarColumnCellsuCharV
virtual void putScalarColumnCellsuCharV(const RefRows &rownrs, const Vector< uChar > *dataPtr)
casacore::StManColumn::getScalarColumnCellsBoolV
virtual void getScalarColumnCellsBoolV(const RefRows &rownrs, Vector< Bool > *dataPtr)
Get the scalar values in some cells of the column.
casacore::StManColumn::putScalarColumnInt64V
virtual void putScalarColumnInt64V(const Vector< Int64 > *dataPtr)
casacore::StManColumn::putColumnSliceCellsComplexV
virtual void putColumnSliceCellsComplexV(const RefRows &rownrs, const Slicer &ns, const Array< Complex > *dataPtr)
casacore::StManColumn::putArrayInt64V
virtual void putArrayInt64V(uInt rownr, const Array< Int64 > *dataPtr)
casacore::StManColumn::getSliceBoolV
virtual void getSliceBoolV(uInt rownr, const Slicer &ns, Array< Bool > *dataPtr)
Get the array value in the given row.
casacore::StManColumn::getColumnSliceCellsStringV
virtual void getColumnSliceCellsStringV(const RefRows &rownrs, const Slicer &ns, Array< String > *dataPtr)
casacore::StManColumn::getuChar
virtual void getuChar(rownr_t rownr, uChar *dataPtr)
casacore::StManColumn::tileShape
virtual IPosition tileShape(rownr_t rownr)
Get the tile shape of the item in the given row.
casacore::StManColumn::putShort
virtual void putShort(rownr_t rownr, const Short *dataPtr)
casacore::StManColumn::getColumnSliceComplexV
virtual void getColumnSliceComplexV(const Slicer &ns, Array< Complex > *dataPtr)
casacore::StManColumn::putArrayColumnCellsStringV
virtual void putArrayColumnCellsStringV(const RefRows &rownrs, const Array< String > *dataPtr)
casacore::StManColumn::getScalarColumnfloatV
virtual void getScalarColumnfloatV(Vector< float > *dataPtr)
casacore::StManColumn::putComplex
virtual void putComplex(rownr_t rownr, const Complex *dataPtr)
casacore::StManColumn::getuInt
virtual void getuInt(rownr_t rownr, uInt *dataPtr)
casacore::StManColumn::putScalarColumnComplexV
virtual void putScalarColumnComplexV(const Vector< Complex > *dataPtr)
casacore::StManColumn::putArrayColumnCellsuShortV
virtual void putArrayColumnCellsuShortV(const RefRows &rownrs, const Array< uShort > *dataPtr)
casacore::StManColumn::getSliceV
virtual void getSliceV(rownr_t rownr, const Slicer &slicer, ArrayBase &dataPtr)
Get a section of the array in the given row.
casacore::StManColumn::getColumnSliceuShortV
virtual void getColumnSliceuShortV(const Slicer &ns, Array< uShort > *dataPtr)
casacore::StManColumn::putArrayDComplexV
virtual void putArrayDComplexV(uInt rownr, const Array< DComplex > *dataPtr)
casacore::StManColumn::putArrayColumnBoolV
virtual void putArrayColumnBoolV(const Array< Bool > *dataPtr)
Put the array values into the entire column.
casacore::StManColumn::putScalarColumnuIntV
virtual void putScalarColumnuIntV(const Vector< uInt > *dataPtr)
casacore::StManColumn::getDComplexV
virtual void getDComplexV(uInt rownr, DComplex *dataPtr)
casacore::StManColumn::ndim
virtual uInt ndim(rownr_t rownr)
Get the dimensionality of the item in the given row.
casacore::StManColumn::getSlicedoubleV
virtual void getSlicedoubleV(uInt rownr, const Slicer &ns, Array< double > *dataPtr)
casacore::StManColumn::getSliceDComplexV
virtual void getSliceDComplexV(uInt rownr, const Slicer &ns, Array< DComplex > *dataPtr)
casacore::StManColumn::throwInvalidOp
void throwInvalidOp(const String &op) const
Throw an "invalid operation" exception for the default implementation of getArray.
casacore::StManColumn::getSliceShortV
virtual void getSliceShortV(uInt rownr, const Slicer &ns, Array< Short > *dataPtr)
casacore::StManColumn::getBoolV
virtual void getBoolV(uInt rownr, Bool *dataPtr)
Get the scalar value in the given row.
casacore::StManColumn::putArrayColumnCellsIntV
virtual void putArrayColumnCellsIntV(const RefRows &rownrs, const Array< Int > *dataPtr)
casacore::StManColumn::putArrayuShortV
virtual void putArrayuShortV(uInt rownr, const Array< uShort > *dataPtr)
casacore::StManColumn::getColumnSliceuIntV
virtual void getColumnSliceuIntV(const Slicer &ns, Array< uInt > *dataPtr)
casacore::StManColumn::putfloat
virtual void putfloat(rownr_t rownr, const float *dataPtr)
casacore::StManColumn::putfloatV
virtual void putfloatV(uInt rownr, const float *dataPtr)
casacore::StManColumn::putSliceIntV
virtual void putSliceIntV(uInt rownr, const Slicer &ns, const Array< Int > *dataPtr)
casacore::StManColumn::getArrayColumnCellsdoubleV
virtual void getArrayColumnCellsdoubleV(const RefRows &rownrs, Array< double > *dataPtr)
casacore::StManColumn::putColumnSliceCellsIntV
virtual void putColumnSliceCellsIntV(const RefRows &rownrs, const Slicer &ns, const Array< Int > *dataPtr)
casacore::StManColumn::getArrayColumnCellsStringV
virtual void getArrayColumnCellsStringV(const RefRows &rownrs, Array< String > *dataPtr)
casacore::StManColumn::putShortV
virtual void putShortV(uInt rownr, const Short *dataPtr)
casacore::StManColumn::shape
virtual IPosition shape(uInt rownr)
casacore::StManColumn::isShapeDefined
virtual Bool isShapeDefined(rownr_t rownr)
Is the value shape defined in the given row?
casacore::StManColumn::putuChar
virtual void putuChar(rownr_t rownr, const uChar *dataPtr)
casacore::StManColumn::shape
virtual IPosition shape(rownr_t rownr)
Get the shape of the item in the given row.
casacore::StManColumn::putArrayColumnCellsdoubleV
virtual void putArrayColumnCellsdoubleV(const RefRows &rownrs, const Array< double > *dataPtr)
casacore::StManColumn::getSlicefloatV
virtual void getSlicefloatV(uInt rownr, const Slicer &ns, Array< float > *dataPtr)
casacore::StManColumn::putArrayColumnShortV
virtual void putArrayColumnShortV(const Array< Short > *dataPtr)
casacore::StManColumn::putSliceComplexV
virtual void putSliceComplexV(uInt rownr, const Slicer &ns, const Array< Complex > *dataPtr)
casacore::StManColumn::getSliceuIntV
virtual void getSliceuIntV(uInt rownr, const Slicer &ns, Array< uInt > *dataPtr)
casacore::StManColumn::getColumnSliceCellsIntV
virtual void getColumnSliceCellsIntV(const RefRows &rownrs, const Slicer &ns, Array< Int > *dataPtr)
casacore::StManColumn::getScalarColumnStringV
virtual void getScalarColumnStringV(Vector< String > *dataPtr)
casacore::StManColumn::~StManColumn
virtual ~StManColumn()
casacore::StManColumn::getInt
virtual void getInt(rownr_t rownr, Int *dataPtr)
casacore::StManColumn::putArrayuCharV
virtual void putArrayuCharV(uInt rownr, const Array< uChar > *dataPtr)
casacore::StManColumn::getIntV
virtual void getIntV(uInt rownr, Int *dataPtr)
casacore::StManColumn::putStringV
virtual void putStringV(uInt rownr, const String *dataPtr)
casacore::StManColumn::putScalarColumnCellsInt64V
virtual void putScalarColumnCellsInt64V(const RefRows &rownrs, const Vector< Int64 > *dataPtr)
casacore::StManColumn::getArrayuIntV
virtual void getArrayuIntV(uInt rownr, Array< uInt > *dataPtr)
casacore::StManColumn::getArrayColumnInt64V
virtual void getArrayColumnInt64V(Array< Int64 > *dataPtr)
casacore::StManColumn::putArrayColumnuCharV
virtual void putArrayColumnuCharV(const Array< uChar > *dataPtr)
casacore::StManColumn::getStringV
virtual void getStringV(uInt rownr, String *dataPtr)
casacore::StManColumn::putScalarColumnV
virtual void putScalarColumnV(const ArrayBase &dataPtr)
Put all scalar values in the column.
casacore::StManColumn::getArrayColumnIntV
virtual void getArrayColumnIntV(Array< Int > *dataPtr)
casacore::StManColumn::getColumnSliceCellsfloatV
virtual void getColumnSliceCellsfloatV(const RefRows &rownrs, const Slicer &ns, Array< float > *dataPtr)
casacore::StManColumn::putSliceuCharV
virtual void putSliceuCharV(uInt rownr, const Slicer &ns, const Array< uChar > *dataPtr)
casacore::StManColumn::getArrayfloatV
virtual void getArrayfloatV(uInt rownr, Array< float > *dataPtr)
casacore::StManColumn::putArrayColumnCellsBoolV
virtual void putArrayColumnCellsBoolV(const RefRows &rownrs, const Array< Bool > *dataPtr)
Put the array values into some cells of the column.
casacore::StManColumn::getScalarColumnIntV
virtual void getScalarColumnIntV(Vector< Int > *dataPtr)
casacore::StManColumn::putArrayColumnComplexV
virtual void putArrayColumnComplexV(const Array< Complex > *dataPtr)
casacore::StManColumn::getArrayIntV
virtual void getArrayIntV(uInt rownr, Array< Int > *dataPtr)
casacore::StManColumn::getArrayColumnCellsuShortV
virtual void getArrayColumnCellsuShortV(const RefRows &rownrs, Array< uShort > *dataPtr)
casacore::StManColumn::putSlicefloatV
virtual void putSlicefloatV(uInt rownr, const Slicer &ns, const Array< float > *dataPtr)
casacore::StManColumn::getScalarColumnCellsdoubleV
virtual void getScalarColumnCellsdoubleV(const RefRows &rownrs, Vector< double > *dataPtr)
casacore::StManColumn::getScalarColumnuCharV
virtual void getScalarColumnuCharV(Vector< uChar > *dataPtr)
casacore::StManColumn::putSliceBoolV
virtual void putSliceBoolV(uInt rownr, const Slicer &ns, const Array< Bool > *dataPtr)
Put the array value into the given row.
casacore::StManColumn::operator=
StManColumn & operator=(const StManColumn &)=delete
The object cannot be assigned to.
casacore::StManColumn::putSliceInt64V
virtual void putSliceInt64V(uInt rownr, const Slicer &ns, const Array< Int64 > *dataPtr)
casacore::StManColumn::getfloat
virtual void getfloat(rownr_t rownr, float *dataPtr)
casacore::StManColumn::StManColumn
StManColumn(int dataType)
Default constructor.
Definition StManColumn.h:78
casacore::StManColumn::putDComplex
virtual void putDComplex(rownr_t rownr, const DComplex *dataPtr)
casacore::StManColumn::putuCharV
virtual void putuCharV(uInt rownr, const uChar *dataPtr)
casacore::StManColumn::getScalarColumnCellsDComplexV
virtual void getScalarColumnCellsDComplexV(const RefRows &rownrs, Vector< DComplex > *dataPtr)
casacore::StManColumn::putArraydoubleV
virtual void putArraydoubleV(uInt rownr, const Array< double > *dataPtr)
casacore::StManColumn::setShape
virtual void setShape(uInt rownr, const IPosition &shape)
casacore::StManColumn::getColumnSliceCellsV
virtual void getColumnSliceCellsV(const RefRows &rownrs, const Slicer &slicer, ArrayBase &dataPtr)
Get a section of some arrays in the column.
casacore::StManColumn::putSliceDComplexV
virtual void putSliceDComplexV(uInt rownr, const Slicer &ns, const Array< DComplex > *dataPtr)
casacore::StManColumn::putSlicedoubleV
virtual void putSlicedoubleV(uInt rownr, const Slicer &ns, const Array< double > *dataPtr)
casacore::StManColumn::putColumnSliceuCharV
virtual void putColumnSliceuCharV(const Slicer &ns, const Array< uChar > *dataPtr)
casacore::StManColumn::getScalarColumnInt64V
virtual void getScalarColumnInt64V(Vector< Int64 > *dataPtr)
casacore::StManColumn::putArrayColumnCellsComplexV
virtual void putArrayColumnCellsComplexV(const RefRows &rownrs, const Array< Complex > *dataPtr)
casacore::StManColumn::setShapeTiled
virtual void setShapeTiled(rownr_t rownr, const IPosition &shape, const IPosition &tileShape)
Set the shape and tile shape of an (variable-shaped) array in the given row.
casacore::StManColumn::putScalarColumnuCharV
virtual void putScalarColumnuCharV(const Vector< uChar > *dataPtr)
casacore::StManColumn::getSliceComplexV
virtual void getSliceComplexV(uInt rownr, const Slicer &ns, Array< Complex > *dataPtr)
casacore::StManColumn::getArrayColumnuIntV
virtual void getArrayColumnuIntV(Array< uInt > *dataPtr)
casacore::StManColumn::getColumnSliceInt64V
virtual void getColumnSliceInt64V(const Slicer &ns, Array< Int64 > *dataPtr)
casacore::StManColumn::getScalarColumnCellsComplexV
virtual void getScalarColumnCellsComplexV(const RefRows &rownrs, Vector< Complex > *dataPtr)
casacore::StManColumn::putArrayColumnV
virtual void putArrayColumnV(const ArrayBase &dataPtr)
Put all array values in the column.
casacore::StManColumn::putComplexV
virtual void putComplexV(uInt rownr, const Complex *dataPtr)
casacore::StManColumn::putColumnSliceBoolV
virtual void putColumnSliceBoolV(const Slicer &ns, const Array< Bool > *dataPtr)
Put the array values into the entire column.
casacore::StManColumn::putScalarColumnCellsBoolV
virtual void putScalarColumnCellsBoolV(const RefRows &rownrs, const Vector< Bool > *dataPtr)
Put the scalar values into some cells of the column.
casacore::StManColumn::getScalarColumnBoolV
virtual void getScalarColumnBoolV(Vector< Bool > *dataPtr)
Get the scalar values in the entire column.
casacore::StManColumn::getBool
virtual void getBool(rownr_t rownr, Bool *dataPtr)
Get the scalar value in the given row.
casacore::StManColumn::putInt
virtual void putInt(rownr_t rownr, const Int *dataPtr)
casacore::StManColumn::getColumnSlicedoubleV
virtual void getColumnSlicedoubleV(const Slicer &ns, Array< double > *dataPtr)
casacore::StManColumn::putArrayColumnCellsuIntV
virtual void putArrayColumnCellsuIntV(const RefRows &rownrs, const Array< uInt > *dataPtr)
casacore::StManColumn::getScalarColumnCellsuShortV
virtual void getScalarColumnCellsuShortV(const RefRows &rownrs, Vector< uShort > *dataPtr)
casacore::StManColumn::putColumnSliceCellsStringV
virtual void putColumnSliceCellsStringV(const RefRows &rownrs, const Slicer &ns, const Array< String > *dataPtr)
casacore::StManColumn::putColumnSliceCellsV
virtual void putColumnSliceCellsV(const RefRows &rownrs, const Slicer &slicer, const ArrayBase &dataPtr)
Put into a section of some arrays in the column.
casacore::StManColumn::putArrayColumnInt64V
virtual void putArrayColumnInt64V(const Array< Int64 > *dataPtr)
casacore::StManColumn::getColumnSliceCellsShortV
virtual void getColumnSliceCellsShortV(const RefRows &rownrs, const Slicer &ns, Array< Short > *dataPtr)
casacore::StManColumn::setShape
virtual void setShape(rownr_t rownr, const IPosition &shape)
Set the shape of an (variable-shaped) array in the given row.
casacore::StManColumn::getColumnSliceStringV
virtual void getColumnSliceStringV(const Slicer &ns, Array< String > *dataPtr)
casacore::StManColumn::putScalarColumnStringV
virtual void putScalarColumnStringV(const Vector< String > *dataPtr)
casacore::StManColumn::putColumnSlicedoubleV
virtual void putColumnSlicedoubleV(const Slicer &ns, const Array< double > *dataPtr)
casacore::StManColumn::putColumnSliceComplexV
virtual void putColumnSliceComplexV(const Slicer &ns, const Array< Complex > *dataPtr)
casacore::StManColumn::putArrayfloatV
virtual void putArrayfloatV(uInt rownr, const Array< float > *dataPtr)
casacore::StManColumn::getArrayColumnComplexV
virtual void getArrayColumnComplexV(Array< Complex > *dataPtr)
casacore::StManColumn::getSliceuCharV
virtual void getSliceuCharV(uInt rownr, const Slicer &ns, Array< uChar > *dataPtr)
casacore::StManColumn::putScalarColumnCellsStringV
virtual void putScalarColumnCellsStringV(const RefRows &rownrs, const Vector< String > *dataPtr)
casacore::StManColumn::putColumnSliceCellsfloatV
virtual void putColumnSliceCellsfloatV(const RefRows &rownrs, const Slicer &ns, const Array< float > *dataPtr)
casacore::StManColumn::getColumnSliceCellsDComplexV
virtual void getColumnSliceCellsDComplexV(const RefRows &rownrs, const Slicer &ns, Array< DComplex > *dataPtr)
casacore::StManColumn::putSliceStringV
virtual void putSliceStringV(uInt rownr, const Slicer &ns, const Array< String > *dataPtr)
casacore::StManColumn::StManColumn
StManColumn(const StManColumn &)=delete
The object cannot be copied.
casacore::StManColumn::putBoolV
virtual void putBoolV(uInt rownr, const Bool *dataPtr)
Put the scalar value in the given row.
casacore::StManColumn::getArraydoubleV
virtual void getArraydoubleV(uInt rownr, Array< double > *dataPtr)
casacore::StManColumn::getuCharV
virtual void getuCharV(uInt rownr, uChar *dataPtr)
casacore::StManColumn::putColumnSliceStringV
virtual void putColumnSliceStringV(const Slicer &ns, const Array< String > *dataPtr)
casacore::StManColumn::getColumnSliceCellsComplexV
virtual void getColumnSliceCellsComplexV(const RefRows &rownrs, const Slicer &ns, Array< Complex > *dataPtr)
casacore::StManColumn::putColumnSliceCellsdoubleV
virtual void putColumnSliceCellsdoubleV(const RefRows &rownrs, const Slicer &ns, const Array< double > *dataPtr)
casacore::StManColumn::putArrayColumnIntV
virtual void putArrayColumnIntV(const Array< Int > *dataPtr)
casacore::StManColumn::putArrayV
virtual void putArrayV(rownr_t rownr, const ArrayBase &dataPtr)
Put the array value into the given row.
casacore::StManColumn::putArrayColumnuIntV
virtual void putArrayColumnuIntV(const Array< uInt > *dataPtr)
casacore::StManColumn::getComplexV
virtual void getComplexV(uInt rownr, Complex *dataPtr)
casacore::StManColumn::tileShape
virtual IPosition tileShape(uInt rownr)
casacore::StManColumn::getDComplex
virtual void getDComplex(rownr_t rownr, DComplex *dataPtr)
casacore::StManColumn::setShapeTiled
virtual void setShapeTiled(uInt rownr, const IPosition &shape, const IPosition &tileShape)
casacore::StManColumn::putArrayIntV
virtual void putArrayIntV(uInt rownr, const Array< Int > *dataPtr)
casacore::StManColumn::putDComplexV
virtual void putDComplexV(uInt rownr, const DComplex *dataPtr)
casacore::StManColumn::getArrayV
virtual void getArrayV(rownr_t rownr, ArrayBase &dataPtr)
Get the array value in the given row.
casacore::StManColumn::putColumnSlicefloatV
virtual void putColumnSlicefloatV(const Slicer &ns, const Array< float > *dataPtr)
casacore::StManColumn::getScalarColumnShortV
virtual void getScalarColumnShortV(Vector< Short > *dataPtr)
casacore::StManColumn::getArrayStringV
virtual void getArrayStringV(uInt rownr, Array< String > *dataPtr)
casacore::StManColumn::getdoubleV
virtual void getdoubleV(uInt rownr, double *dataPtr)
casacore::StManColumn::getScalarColumnCellsuCharV
virtual void getScalarColumnCellsuCharV(const RefRows &rownrs, Vector< uChar > *dataPtr)
casacore::StManColumn::getColumnSliceuCharV
virtual void getColumnSliceuCharV(const Slicer &ns, Array< uChar > *dataPtr)
casacore::StManColumn::getColumnSliceDComplexV
virtual void getColumnSliceDComplexV(const Slicer &ns, Array< DComplex > *dataPtr)
casacore::StManColumn::getfloatV
virtual void getfloatV(uInt rownr, float *dataPtr)
casacore::StManColumn::getSliceInt64V
virtual void getSliceInt64V(uInt rownr, const Slicer &ns, Array< Int64 > *dataPtr)
casacore::StManColumn::putColumnSliceuShortV
virtual void putColumnSliceuShortV(const Slicer &ns, const Array< uShort > *dataPtr)
casacore::StManColumn::getuShort
virtual void getuShort(rownr_t rownr, uShort *dataPtr)
casacore::StManColumn::getSliceStringV
virtual void getSliceStringV(uInt rownr, const Slicer &ns, Array< String > *dataPtr)
casacore::StManColumn::getArrayComplexV
virtual void getArrayComplexV(uInt rownr, Array< Complex > *dataPtr)
casacore::StManColumn::putArrayColumnCellsDComplexV
virtual void putArrayColumnCellsDComplexV(const RefRows &rownrs, const Array< DComplex > *dataPtr)
casacore::StManColumn::getArrayColumnDComplexV
virtual void getArrayColumnDComplexV(Array< DComplex > *dataPtr)
casacore::StManColumn::putScalarColumnCellsdoubleV
virtual void putScalarColumnCellsdoubleV(const RefRows &rownrs, const Vector< double > *dataPtr)
casacore::StManColumn::getColumnSliceShortV
virtual void getColumnSliceShortV(const Slicer &ns, Array< Short > *dataPtr)
casacore::StManColumn::putuShort
virtual void putuShort(rownr_t rownr, const uShort *dataPtr)
casacore::StManColumn::putColumnSliceCellsShortV
virtual void putColumnSliceCellsShortV(const RefRows &rownrs, const Slicer &ns, const Array< Short > *dataPtr)
casacore::StManColumn::getScalarColumnCellsfloatV
virtual void getScalarColumnCellsfloatV(const RefRows &rownrs, Vector< float > *dataPtr)
casacore::StManColumn::putuShortV
virtual void putuShortV(uInt rownr, const uShort *dataPtr)
casacore::StManColumn::getArrayColumnCellsShortV
virtual void getArrayColumnCellsShortV(const RefRows &rownrs, Array< Short > *dataPtr)
casacore::StManColumn::getuIntV
virtual void getuIntV(uInt rownr, uInt *dataPtr)
casacore::StManColumn::putScalarColumnCellsV
virtual void putScalarColumnCellsV(const RefRows &rownrs, const ArrayBase &dataPtr)
Put some scalar values in the column.
casacore::StManColumn::getArrayColumnCellsDComplexV
virtual void getArrayColumnCellsDComplexV(const RefRows &rownrs, Array< DComplex > *dataPtr)
casacore::StManColumn::getArrayColumnCellsuIntV
virtual void getArrayColumnCellsuIntV(const RefRows &rownrs, Array< uInt > *dataPtr)
casacore::StManColumn::getScalarColumnCellsShortV
virtual void getScalarColumnCellsShortV(const RefRows &rownrs, Vector< Short > *dataPtr)
casacore::StManColumn::putColumnSliceInt64V
virtual void putColumnSliceInt64V(const Slicer &ns, const Array< Int64 > *dataPtr)
casacore::StManColumn::getArrayColumnfloatV
virtual void getArrayColumnfloatV(Array< float > *dataPtr)
casacore::StManColumn::putScalarColumnShortV
virtual void putScalarColumnShortV(const Vector< Short > *dataPtr)
casacore::StManColumn::getComplex
virtual void getComplex(rownr_t rownr, Complex *dataPtr)
casacore::StManColumn::putArrayColumndoubleV
virtual void putArrayColumndoubleV(const Array< double > *dataPtr)
casacore::StManColumn::getArrayColumnuCharV
virtual void getArrayColumnuCharV(Array< uChar > *dataPtr)
casacore::StManColumn::getColumnSliceCellsBoolV
virtual void getColumnSliceCellsBoolV(const RefRows &rownrs, const Slicer &ns, Array< Bool > *dataPtr)
Get the array values in some cells of the column.
casacore::StManColumn::putBool
virtual void putBool(rownr_t rownr, const Bool *dataPtr)
Put the scalar value in the given row.
casacore::StManColumn::getArrayColumnStringV
virtual void getArrayColumnStringV(Array< String > *dataPtr)
casacore::StManColumn::putColumnSliceDComplexV
virtual void putColumnSliceDComplexV(const Slicer &ns, const Array< DComplex > *dataPtr)
casacore::StManColumn::putColumnSliceShortV
virtual void putColumnSliceShortV(const Slicer &ns, const Array< Short > *dataPtr)
casacore::StManColumn::putScalarColumnCellsComplexV
virtual void putScalarColumnCellsComplexV(const RefRows &rownrs, const Vector< Complex > *dataPtr)
casacore::StManColumn::putScalarColumnfloatV
virtual void putScalarColumnfloatV(const Vector< float > *dataPtr)
casacore::StManColumn::putIntV
virtual void putIntV(uInt rownr, const Int *dataPtr)
casacore::StManColumn::putColumnSliceIntV
virtual void putColumnSliceIntV(const Slicer &ns, const Array< Int > *dataPtr)
casacore::StManColumn::putArrayComplexV
virtual void putArrayComplexV(uInt rownr, const Array< Complex > *dataPtr)
casacore::StManColumn::getArrayuCharV
virtual void getArrayuCharV(uInt rownr, Array< uChar > *dataPtr)
casacore::StManColumn::putArrayuIntV
virtual void putArrayuIntV(uInt rownr, const Array< uInt > *dataPtr)
casacore::StManColumn::getArrayColumnCellsIntV
virtual void getArrayColumnCellsIntV(const RefRows &rownrs, Array< Int > *dataPtr)
casacore::StManColumn::putScalarColumnuShortV
virtual void putScalarColumnuShortV(const Vector< uShort > *dataPtr)
casacore::StManColumn::putColumnSliceuIntV
virtual void putColumnSliceuIntV(const Slicer &ns, const Array< uInt > *dataPtr)
casacore::StManColumn::getColumnSlicefloatV
virtual void getColumnSlicefloatV(const Slicer &ns, Array< float > *dataPtr)
casacore::StManColumn::putScalarColumnIntV
virtual void putScalarColumnIntV(const Vector< Int > *dataPtr)
casacore::StManColumn::getShortV
virtual void getShortV(uInt rownr, Short *dataPtr)
casacore::StManColumn::getArrayColumnCellsComplexV
virtual void getArrayColumnCellsComplexV(const RefRows &rownrs, Array< Complex > *dataPtr)
casacore::StManColumn::getColumnSliceCellsdoubleV
virtual void getColumnSliceCellsdoubleV(const RefRows &rownrs, const Slicer &ns, Array< double > *dataPtr)
casacore::StManColumn::getScalarColumnuIntV
virtual void getScalarColumnuIntV(Vector< uInt > *dataPtr)
casacore::StManColumn::getScalarColumnuShortV
virtual void getScalarColumnuShortV(Vector< uShort > *dataPtr)
casacore::StManColumn::getArrayShortV
virtual void getArrayShortV(uInt rownr, Array< Short > *dataPtr)
casacore::StManColumn::putScalarColumnCellsIntV
virtual void putScalarColumnCellsIntV(const RefRows &rownrs, const Vector< Int > *dataPtr)
casacore::StManColumn::putScalarColumnDComplexV
virtual void putScalarColumnDComplexV(const Vector< DComplex > *dataPtr)
casacore::StManColumn::getColumnSliceCellsuIntV
virtual void getColumnSliceCellsuIntV(const RefRows &rownrs, const Slicer &ns, Array< uInt > *dataPtr)
casacore::StManColumn::getArrayuShortV
virtual void getArrayuShortV(uInt rownr, Array< uShort > *dataPtr)
casacore::StManColumn::putScalarColumnCellsShortV
virtual void putScalarColumnCellsShortV(const RefRows &rownrs, const Vector< Short > *dataPtr)
casacore::StManColumn::putArrayColumnCellsInt64V
virtual void putArrayColumnCellsInt64V(const RefRows &rownrs, const Array< Int64 > *dataPtr)
casacore::StManColumn::getColumnSliceCellsuCharV
virtual void getColumnSliceCellsuCharV(const RefRows &rownrs, const Slicer &ns, Array< uChar > *dataPtr)
casacore::StManColumn::getShort
virtual void getShort(rownr_t rownr, Short *dataPtr)
casacore::StManColumn::getArrayColumnBoolV
virtual void getArrayColumnBoolV(Array< Bool > *dataPtr)
Get the array values in the entire column.
casacore::StManColumn::getScalarColumnCellsInt64V
virtual void getScalarColumnCellsInt64V(const RefRows &rownrs, Vector< Int64 > *dataPtr)
casacore::StManColumn::putdouble
virtual void putdouble(rownr_t rownr, const double *dataPtr)
casacore::StManColumn::getdouble
virtual void getdouble(rownr_t rownr, double *dataPtr)
casacore::StManColumn::getArrayColumndoubleV
virtual void getArrayColumndoubleV(Array< double > *dataPtr)
casacore::StManColumn::putScalarColumndoubleV
virtual void putScalarColumndoubleV(const Vector< double > *dataPtr)
casacore::String
String: the storage and methods of handling collections of characters.
Definition String.h:223
casacore::Vector
Definition Vector.h:82
casacore
this file contains all the compiler specific defines
Definition mainpage.dox:28
casacore::uChar
unsigned char uChar
Definition aipstype.h:45
casacore::Short
short Short
Definition aipstype.h:46
casacore::uInt
unsigned int uInt
Definition aipstype.h:49
casacore::uShort
unsigned short uShort
Definition aipstype.h:47
casacore::Int
int Int
Definition aipstype.h:48
casacore::Bool
bool Bool
Define the standard types used by Casacore.
Definition aipstype.h:40
casacore::rownr_t
uInt64 rownr_t
Define the type of a row number in a table.
Definition aipsxtype.h:44