Loading...
Searching...
No Matches
ArrayColumnBase.h
Go to the documentation of this file.
//# ArrayColumnBase.h: base class for access to an array table column
//# Copyright (C) 2013
//# 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_ARRAYCOLUMNBASE_H
#define TABLES_ARRAYCOLUMNBASE_H
//# Includes
#include <casacore/casa/aips.h>
#include <casacore/tables/Tables/TableColumn.h>
#include <casacore/casa/Arrays/Vector.h>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
//# Forward Declarations
class BaseSlicesFunctor;
class RefRows;
class ColumnSlicer;
class IPosition;
class Slice;
class Slicer;
class String;
// <summary>
// Read and write access to an array table column with arbitrary data type
// </summary>
// <use visibility=export>
// <reviewed reviewer="dschieb" date="1994/08/10" tests="none">
// </reviewed>
// <prerequisite>
// <li> Table
// <li> TableColumn
// </prerequisite>
// <etymology>
// ArrayColumn<T> gives read and write access to an column in a table
// containing an array with data type T.
// </etymology>
// <synopsis>
// ArrayColumnBase is the base class of the templated class ArrayColumn
// which allows readonly access to a column containing arrays with an
// arbitrary data type. It can handle direct as well as indirect arrays.
//
// All get and put functions are implemented in this base class as
// non-templated functions. Type-specific operations are done by means
// of virtual functions in the Array classes.
// </synopsis>
// <example>
// See module <linkto module="Tables#open">Tables</linkto>.
// </example>
class ArrayColumnBase : public TableColumn
{
public:
// The default constructor creates a null object, i.e. it
// does not reference a table column.
ArrayColumnBase();
// Construct for the given column in the given table.
ArrayColumnBase (const Table&, const String& columnName);
// Construct from the given table column.
// This constructor is useful if first a table column was constructed,
// its type is determined and thereafter used to construct the
// correct column object.
ArrayColumnBase (const TableColumn& column);
// Copy constructor (reference semantics).
ArrayColumnBase (const ArrayColumnBase&);
~ArrayColumnBase();
// Assignment uses reference semantics, thus works the same
// as function reference.
ArrayColumnBase& operator= (const ArrayColumnBase&);
// Change the reference to another column.
// This is in fact an assignment operator with reference semantics.
// It removes the reference to the current column and creates
// a reference to the column referenced in the other object.
// It will handle null objects correctly.
void reference (const ArrayColumnBase&);
// Get the #dimensions of an array in a particular cell.
// If the cell does not contain an array, 0 is returned.
// Use the function isDefined to test if the cell contains an array.
uInt ndim (rownr_t rownr) const
{ TABLECOLUMNCHECKROW(rownr); return baseColPtr_p->ndim (rownr); }
// Get the shape of an array in a particular cell.
// If the cell does not contain an array, a 0-dim shape is returned.
// Use the function isDefined to test if the cell contains an array.
IPosition shape (rownr_t rownr) const
{ TABLECOLUMNCHECKROW(rownr); return baseColPtr_p->shape (rownr); }
// Counterparts of the acbGet() functions below not checking shapes, etc.
// They are faster and can be used for performance reasons if one
// knows for sure that the arguments are correct.
// E.g., they are used internally in virtual column engines.
// <group>
void baseGet (rownr_t rownr, ArrayBase& array) const
{ baseColPtr_p->getArray (rownr, array); }
void baseGetSlice (rownr_t rownr, const Slicer& arraySection,
ArrayBase& array) const
{ baseColPtr_p->getSlice (rownr, arraySection, array); }
// </group>
// Get the array value in a particular cell (i.e. table row).
// The row numbers count from 0 until #rows-1.
void acbGet (rownr_t rownr, ArrayBase& array, Bool resize) const;
// Get a slice of an N-dimensional array in a particular cell
// (i.e. table row).
// The row numbers count from 0 until #rows-1.
// The dimensionality of the slice must match the dimensionality
// of the table array and the slice definition should not exceed
// the shape of the table array.
void acbGetSlice (rownr_t rownr, const Slicer& arraySection, ArrayBase& array,
Bool resize) const;
// Get an irregular slice of an N-dimensional array in a particular cell
// (i.e. table row) as given by the vectors of Slice objects.
// The outer vector represents the array axes.
// A missing or empty axis means the entire axis.
// The inner vector represents the slices to take for each axis.
// For example, to get slices from 2-dim arrays:
// <srcblock>
// Vector<Vector<Slice> > slices(2); // 2-dim
// slices[1].resize (3); // 3 slices in 2nd dim
// slices[1][0] = Slice(100,20);
// slices[1][1] = Slice(200,18);
// slices[1][2] = Slice(538,30,2);
// // Get data. Vector of first axis is empty, thus entire axis is read.
// Array<Complex> data = dataCol.getColumn (slices);
// </srcblock>
// If the column contains n-dim arrays, the resulting array is (n+1)-dim.
// with the last dimension representing the number of rows and the
// other dimensions representing the shape of the slice.
// The arrays in the column must have the same shape in all cells.
void acbGetSlice (rownr_t rownr,
const Vector<Vector<Slice> >& arraySlices,
ArrayBase& arr, Bool resize) const;
// Get the array of all values in a column.
// If the column contains n-dim arrays, the resulting array is (n+1)-dim
// with the last dimension representing the number of rows.
// The arrays in the column must have the same shape in all cells.
void acbGetColumn (ArrayBase& array, Bool resize) const;
// Get regular slices from all arrays in the column.
// If the column contains n-dim arrays, the resulting array is (n+1)-dim.
// with the last dimension representing the number of rows and the
// other dimensions representing the shape of the slice.
// The arrays in the column must have the same shape in all cells.
void acbGetColumn (const Slicer& arraySection, ArrayBase& array,
Bool resize) const;
// Get irregular slices from all arrays in the column as given by the
// vectors of Slice objects. The outer vector represents the array axes.
// A missing or empty axis means the entire axis.
// The inner vector represents the slices to take for each axis.
// For example, to get slices from 2-dim arrays:
// <srcblock>
// Vector<Vector<Slice> > slices(2); // 2-dim
// slices[1].resize (3); // 3 slices in 2nd dim
// slices[1][0] = Slice(100,20);
// slices[1][1] = Slice(200,18);
// slices[1][2] = Slice(538,30,2);
// // Get data. Vector of first axis is empty, thus entire axis is read.
// Array<Complex> data = dataCol.getColumn (slices);
// </srcblock>
// If the column contains n-dim arrays, the resulting array is (n+1)-dim.
// with the last dimension representing the number of rows and the
// other dimensions representing the shape of the slice.
// The arrays in the column must have the same shape in all cells.
void acbGetColumn (const Vector<Vector<Slice> >& arraySection,
ArrayBase& array,
Bool resize) const;
// Get the array of some values in a column.
// The Slicer object can be used to specify start, end (or length),
// and stride of the rows to get.
// If the column contains n-dim arrays, the resulting array is (n+1)-dim
// with the last dimension representing the number of rows in the slicer.
// The arrays in the column must have the same shape in all those cells.
void acbGetColumnRange (const Slicer& rowRange, ArrayBase& arr,
Bool resize) const;
void acbGetColumnCells (const RefRows& rownrs, ArrayBase& arr,
Bool resize) const;
// Get slices from some arrays in a column.
// The first Slicer object can be used to specify start, end (or length),
// and stride of the rows to get. The second Slicer object can be
// used to specify the slice to take from each array.
// If the column contains n-dim arrays, the resulting array is (n+1)-dim
// with the last dimension representing the number of rows in the slicer.
// The arrays in the column must have the same shape in all those cells.
// <group>
void acbGetColumnRange (const Slicer& rowRange,
const Slicer& arraySection, ArrayBase& arr,
Bool resize) const;
void acbGetColumnCells (const RefRows& rownrs,
const Slicer& arraySection, ArrayBase& arr,
Bool resize) const;
// </group>
// Get various slices from the given rows.
void acbGetColumnCells (const RefRows& rows,
const ColumnSlicer& columnSlicer,
ArrayBase& destination,
Bool resize) const;
// Set the shape of the array in the given row.
// Setting the shape is needed if the array is put in slices,
// otherwise the table system would not know the shape.
// <group>
void setShape (rownr_t rownr, const IPosition& shape);
// Try to store the array in a tiled way using the given tile shape.
void setShape (rownr_t rownr, const IPosition& shape,
const IPosition& tileShape);
// </group>
// Counterparts of the acbPut() functions below not checking shapes, etc.
// They are faster and can be used for performance reasons if one
// knows for sure that the arguments are correct.
// E.g., they are used internally in virtual column engines.
// <group>
void basePut (rownr_t rownr, const ArrayBase& array)
{ baseColPtr_p->putArray (rownr, array); }
void basePutSlice (rownr_t rownr, const Slicer& arraySection,
const ArrayBase& array)
{ baseColPtr_p->putSlice (rownr, arraySection, array); }
// </group>
// Put the array in a particular cell (i.e. table row).
// The row numbers count from 0 until #rows-1.
// If the shape of the table array in that cell has not already been
// defined, it will be defined implicitly.
void acbPut (rownr_t rownr, const ArrayBase& array);
// Put into a slice of an N-dimensional array in a particular cell.
// The row numbers count from 0 until #rows-1.
// The shape of the table array must have been defined.
// The dimensionality of the slice must match the dimensionality
// of the table array and the slice definition should not exceed
// the shape of the table array.
void acbPutSlice (rownr_t rownr, const Slicer& arraySection,
const ArrayBase& array);
void acbPutSlice (rownr_t rownr, const Vector<Vector<Slice> >& arraySlices,
const ArrayBase& arr);
// Put the array of all values in the column.
// If the column contains n-dim arrays, the source array must be (n+1)-dim
// with the last dimension representing the number of rows.
void acbPutColumn (const ArrayBase& array);
// Put into subsections of the table arrays in the entire column.
// If the column contains n-dim arrays, the source array is (n+1)-dim
// with the last dimension representing the number of rows and
// other dimensions representing the shape of the slice.
// The dimensionality of the slice must match the dimensionality
// of the table array, thus must be n-dim. Also the slice definition
// should not exceed the shape of the table arrays.
void acbPutColumn (const Slicer& arraySection, const ArrayBase& array);
void acbPutColumn (const Vector<Vector<Slice> >& arraySlices,
const ArrayBase& arr);
// Put the array of some values in the column.
// The Slicer object can be used to specify start, end (or length),
// and stride of the rows to put.
// If the column contains n-dim arrays, the source array must be (n+1)-dim
// with the last dimension representing the number of rows in the slicer.
// <group>
void acbPutColumnRange (const Slicer& rowRange, const ArrayBase& arr);
void acbPutColumnCells (const RefRows& rownrs, const ArrayBase& arr);
// </group>
// Put into subsection of the table arrays in some rows of the column.
// The first Slicer object can be used to specify start, end (or length),
// and stride of the rows to put. The second Slicer object can be
// used to specify the slice to take from each array.
// If the column contains n-dim arrays, the source array must be (n+1)-dim
// with the last dimension representing the number of rows in the slicer.
// <group>
void acbPutColumnRange (const Slicer& rowRange,
const Slicer& arraySection, const ArrayBase& arr);
void acbPutColumnCells (const RefRows& rownrs,
const Slicer& arraySection, const ArrayBase& arr);
// </group>
// Put various slices in the given rows.
// <group>
void acbPutColumnCells (const RefRows& rows,
const Vector<Vector<Slice> >& arraySlices,
const ArrayBase& source);
void acbPutColumnCells (const RefRows& rows,
const ColumnSlicer& columnSlicer,
const ArrayBase& source);
// </group>
// Put the same value in all cells of the column.
void acbFillColumn (const ArrayBase& value);
// Put the contents of that column into this one.
void acbPutColumn (const ArrayColumnBase& that);
// Adapt the shape of the array if possible. If the array is empty or
// if <src>resize=True</src>, the array is resized if needed.
// Otherwise checkShape is used to throw an exception if not conforming.
void adaptShape (const IPosition& shp,
ArrayBase& arr, Bool resize,
Int64 rownr, const String& where) const;
// Throw an exception if the array does not have the expected shape.
// However, False is returned if noSlicing and canChangeShape_p are True
// (meaning no slices are put and the shape of a full row can change).
// The column name is made part of the error message, as well as the rownr
// if it is not negative (meaning a put of a column).
Bool checkShape (const IPosition& expShape, const IPosition& arrShape,
Bool noSlicing, Int64 rownr, const String& where) const;
// A common function used by all functions that can get or put irregular
// array slices. The functor performs the get or put operation.
void handleSlices (const Vector<Vector<Slice> >& slices,
BaseSlicesFunctor& functor,
const Slicer& slicer,
const ArrayBase& array) const;
};
// <synopsis>
// ColumnSlicer is used in one of the ArrayColumn::getColumnCells functions.
// That method takes a potentially complex/ selection of data out of a
// column cell (e.g., multiple slices along each axis) and then puts them
// into a selection of a destination array.
// This is most easily represented as a set of source,destination slicers
// where one is applied to the cell and the other to the destination array.
// </synopsis>
class ColumnSlicer
{
public:
// Construct the object.
// It takes over the pointers to the Slicer objects and deletes them
// in the destructor.
// The shape parameter is the shape of the destination array excluding
// the row axis.
ColumnSlicer (const IPosition& shape,
const Vector<Slicer*>& dataSlicers,
const Vector<Slicer*>& destinationSlicers);
// The destructor deletes all Slicer objects.
~ColumnSlicer();
// Get the data slicers.
const Vector<Slicer*>& getDataSlicers() const
{ return dataSlicers_p; }
// Get the desintation slicers.
const Vector<Slicer*>& getDestinationSlicers() const
{ return destinationSlicers_p; }
// Get the shape.
const IPosition& shape() const
{ return shape_p; }
private:
// Delete all Slicer objects.
void freeSlicers();
// Check if the slicers match the array shape.
String validateParameters() const;
//# Data members.
Vector<Slicer*> dataSlicers_p;
Vector<Slicer*> destinationSlicers_p;
IPosition shape_p;
};
} //# NAMESPACE CASACORE - END
#endif
TABLECOLUMNCHECKROW
#define TABLECOLUMNCHECKROW(ROWNR)
Definition TableColumn.h:49
casacore::ArrayBase
Non-templated base class for templated Array class.
Definition ArrayBase.h:71
casacore::ArrayColumnBase::acbPutSlice
void acbPutSlice(rownr_t rownr, const Vector< Vector< Slice > > &arraySlices, const ArrayBase &arr)
casacore::ArrayColumnBase::reference
void reference(const ArrayColumnBase &)
Change the reference to another column.
casacore::ArrayColumnBase::acbGetColumnCells
void acbGetColumnCells(const RefRows &rownrs, const Slicer &arraySection, ArrayBase &arr, Bool resize) const
casacore::ArrayColumnBase::acbGetColumn
void acbGetColumn(const Vector< Vector< Slice > > &arraySection, ArrayBase &array, Bool resize) const
Get irregular slices from all arrays in the column as given by the vectors of Slice objects.
casacore::ArrayColumnBase::baseGetSlice
void baseGetSlice(rownr_t rownr, const Slicer &arraySection, ArrayBase &array) const
Definition ArrayColumnBase.h:132
casacore::ArrayColumnBase::acbGetColumn
void acbGetColumn(ArrayBase &array, Bool resize) const
Get the array of all values in a column.
casacore::ArrayColumnBase::acbPutColumn
void acbPutColumn(const ArrayBase &array)
Put the array of all values in the column.
casacore::ArrayColumnBase::acbPutColumnCells
void acbPutColumnCells(const RefRows &rownrs, const Slicer &arraySection, const ArrayBase &arr)
casacore::ArrayColumnBase::acbGetColumnRange
void acbGetColumnRange(const Slicer &rowRange, ArrayBase &arr, Bool resize) const
Get the array of some values in a column.
casacore::ArrayColumnBase::handleSlices
void handleSlices(const Vector< Vector< Slice > > &slices, BaseSlicesFunctor &functor, const Slicer &slicer, const ArrayBase &array) const
A common function used by all functions that can get or put irregular array slices.
casacore::ArrayColumnBase::setShape
void setShape(rownr_t rownr, const IPosition &shape, const IPosition &tileShape)
Try to store the array in a tiled way using the given tile shape.
casacore::ArrayColumnBase::checkShape
Bool checkShape(const IPosition &expShape, const IPosition &arrShape, Bool noSlicing, Int64 rownr, const String &where) const
Throw an exception if the array does not have the expected shape.
casacore::ArrayColumnBase::acbGetColumnRange
void acbGetColumnRange(const Slicer &rowRange, const Slicer &arraySection, ArrayBase &arr, Bool resize) const
Get slices from some arrays in a column.
casacore::ArrayColumnBase::~ArrayColumnBase
~ArrayColumnBase()
casacore::ArrayColumnBase::ArrayColumnBase
ArrayColumnBase(const Table &, const String &columnName)
Construct for the given column in the given table.
casacore::ArrayColumnBase::acbPutColumn
void acbPutColumn(const Slicer &arraySection, const ArrayBase &array)
Put into subsections of the table arrays in the entire column.
casacore::ArrayColumnBase::acbGetColumnCells
void acbGetColumnCells(const RefRows &rownrs, ArrayBase &arr, Bool resize) const
casacore::ArrayColumnBase::acbGetColumnCells
void acbGetColumnCells(const RefRows &rows, const ColumnSlicer &columnSlicer, ArrayBase &destination, Bool resize) const
Get various slices from the given rows.
casacore::ArrayColumnBase::acbPutColumn
void acbPutColumn(const ArrayColumnBase &that)
Put the contents of that column into this one.
casacore::ArrayColumnBase::ArrayColumnBase
ArrayColumnBase(const ArrayColumnBase &)
Copy constructor (reference semantics).
casacore::ArrayColumnBase::acbPutColumnCells
void acbPutColumnCells(const RefRows &rows, const Vector< Vector< Slice > > &arraySlices, const ArrayBase &source)
Put various slices in the given rows.
casacore::ArrayColumnBase::ArrayColumnBase
ArrayColumnBase(const TableColumn &column)
Construct from the given table column.
casacore::ArrayColumnBase::acbPutColumnRange
void acbPutColumnRange(const Slicer &rowRange, const Slicer &arraySection, const ArrayBase &arr)
Put into subsection of the table arrays in some rows of the column.
casacore::ArrayColumnBase::acbPutColumnCells
void acbPutColumnCells(const RefRows &rows, const ColumnSlicer &columnSlicer, const ArrayBase &source)
casacore::ArrayColumnBase::baseGet
void baseGet(rownr_t rownr, ArrayBase &array) const
Counterparts of the acbGet() functions below not checking shapes, etc.
Definition ArrayColumnBase.h:130
casacore::ArrayColumnBase::basePut
void basePut(rownr_t rownr, const ArrayBase &array)
Counterparts of the acbPut() functions below not checking shapes, etc.
Definition ArrayColumnBase.h:258
casacore::ArrayColumnBase::acbGetSlice
void acbGetSlice(rownr_t rownr, const Slicer &arraySection, ArrayBase &array, Bool resize) const
Get a slice of an N-dimensional array in a particular cell (i.e.
casacore::ArrayColumnBase::acbPut
void acbPut(rownr_t rownr, const ArrayBase &array)
Put the array in a particular cell (i.e.
casacore::ArrayColumnBase::basePutSlice
void basePutSlice(rownr_t rownr, const Slicer &arraySection, const ArrayBase &array)
Definition ArrayColumnBase.h:260
casacore::ArrayColumnBase::adaptShape
void adaptShape(const IPosition &shp, ArrayBase &arr, Bool resize, Int64 rownr, const String &where) const
Adapt the shape of the array if possible.
casacore::ArrayColumnBase::acbGet
void acbGet(rownr_t rownr, ArrayBase &array, Bool resize) const
Get the array value in a particular cell (i.e.
casacore::ArrayColumnBase::operator=
ArrayColumnBase & operator=(const ArrayColumnBase &)
Assignment uses reference semantics, thus works the same as function reference.
casacore::ArrayColumnBase::acbGetSlice
void acbGetSlice(rownr_t rownr, const Vector< Vector< Slice > > &arraySlices, ArrayBase &arr, Bool resize) const
Get an irregular slice of an N-dimensional array in a particular cell (i.e.
casacore::ArrayColumnBase::ArrayColumnBase
ArrayColumnBase()
The default constructor creates a null object, i.e.
casacore::ArrayColumnBase::acbFillColumn
void acbFillColumn(const ArrayBase &value)
Put the same value in all cells of the column.
casacore::ArrayColumnBase::acbGetColumn
void acbGetColumn(const Slicer &arraySection, ArrayBase &array, Bool resize) const
Get regular slices from all arrays in the column.
casacore::ArrayColumnBase::setShape
void setShape(rownr_t rownr, const IPosition &shape)
Set the shape of the array in the given row.
casacore::ArrayColumnBase::ndim
uInt ndim(rownr_t rownr) const
Get the #dimensions of an array in a particular cell.
Definition ArrayColumnBase.h:116
casacore::ArrayColumnBase::acbPutColumnCells
void acbPutColumnCells(const RefRows &rownrs, const ArrayBase &arr)
casacore::ArrayColumnBase::acbPutColumnRange
void acbPutColumnRange(const Slicer &rowRange, const ArrayBase &arr)
Put the array of some values in the column.
casacore::ArrayColumnBase::shape
IPosition shape(rownr_t rownr) const
Get the shape of an array in a particular cell.
Definition ArrayColumnBase.h:122
casacore::ArrayColumnBase::acbPutSlice
void acbPutSlice(rownr_t rownr, const Slicer &arraySection, const ArrayBase &array)
Put into a slice of an N-dimensional array in a particular cell.
casacore::ArrayColumnBase::acbPutColumn
void acbPutColumn(const Vector< Vector< Slice > > &arraySlices, const ArrayBase &arr)
casacore::BaseSlicesFunctor
Definition ArrayColumnFunc.h:44
casacore::ColumnSlicer
Definition ArrayColumnBase.h:374
casacore::ColumnSlicer::shape_p
IPosition shape_p
Definition ArrayColumnBase.h:411
casacore::ColumnSlicer::validateParameters
String validateParameters() const
Check if the slicers match the array shape.
casacore::ColumnSlicer::getDestinationSlicers
const Vector< Slicer * > & getDestinationSlicers() const
Get the desintation slicers.
Definition ArrayColumnBase.h:394
casacore::ColumnSlicer::destinationSlicers_p
Vector< Slicer * > destinationSlicers_p
Definition ArrayColumnBase.h:410
casacore::ColumnSlicer::shape
const IPosition & shape() const
Get the shape.
Definition ArrayColumnBase.h:398
casacore::ColumnSlicer::freeSlicers
void freeSlicers()
Delete all Slicer objects.
casacore::ColumnSlicer::getDataSlicers
const Vector< Slicer * > & getDataSlicers() const
Get the data slicers.
Definition ArrayColumnBase.h:390
casacore::ColumnSlicer::ColumnSlicer
ColumnSlicer(const IPosition &shape, const Vector< Slicer * > &dataSlicers, const Vector< Slicer * > &destinationSlicers)
Construct the object.
casacore::ColumnSlicer::dataSlicers_p
Vector< Slicer * > dataSlicers_p
Definition ArrayColumnBase.h:409
casacore::ColumnSlicer::~ColumnSlicer
~ColumnSlicer()
The destructor deletes all Slicer objects.
casacore::IPosition
Definition IPosition.h:117
casacore::RefRows
Definition RefRows.h:84
casacore::Slice
Definition Slice.h:89
casacore::Slicer
Definition Slicer.h:287
casacore::String
String: the storage and methods of handling collections of characters.
Definition String.h:223
casacore::TableColumn::TableColumn
TableColumn()
The default constructor creates a null object, i.e.
casacore::TableColumn::tileShape
IPosition tileShape(rownr_t rownr) const
Get the tile shape of an array in a particular cell.
Definition TableColumn.h:233
casacore::TableColumn::baseColPtr_p
BaseColumn * baseColPtr_p
Definition TableColumn.h:386
casacore::Table
Definition Table.h:157
casacore::Vector
Definition Vector.h:82
casacore
this file contains all the compiler specific defines
Definition mainpage.dox:28
casacore::array
T * array
The actual storage.
Definition Block.h:689
casacore::uInt
unsigned int uInt
Definition aipstype.h:49
casacore::Int64
long long Int64
Define the extra non-standard types used by Casacore (like proposed uSize, Size).
Definition aipsxtype.h:36
casacore::Bool
bool Bool
Define the standard types used by Casacore.
Definition aipstype.h:40
casacore::value
NewDelAllocator< T > NewDelAllocator< T >::value
Definition Allocator.h:369
casacore::rownr_t
uInt64 rownr_t
Define the type of a row number in a table.
Definition aipsxtype.h:44