Read and write access to an array table column with arbitrary data type. More...

#include <ArrayColumn.h>

Inheritance diagram for casa::ArrayColumn< T >:

Public Member Functions
	ArrayColumn ()
	The default constructor creates a null object, i.e.
	ArrayColumn (const Table &, const String &columnName)
	Construct for the given column in the given table.
	ArrayColumn (const TableColumn &)
	Construct from the given table column.
	ArrayColumn (const ArrayColumn< T > &)
	Copy constructor (reference semantics).
	~ArrayColumn ()
virtual TableColumn *	clone () const
	Clone the object.
ArrayColumn< T > &	operator= (const ArrayColumn< T > &)
	Assignment uses reference semantics, thus works the same as function reference.
void	reference (const ArrayColumn< T > &)
	Change the reference to another column.
void	attach (const Table &table, const String &columnName)
	Attach a column to the object.
uInt	ndim (uInt rownr) const
	Get the #dimensions of an array in a particular cell.
IPosition	shape (uInt rownr) const
	Get the shape of an array in a particular cell.
void	get (uInt rownr, Array< T > &array, Bool resize=False) const
	Get the array value in a particular cell (i.e.
Array< T >	get (uInt rownr) const
Array< T >	operator() (uInt rownr) const
void	getSlice (uInt rownr, const Slicer &arraySection, Array< T > &array, Bool resize=False) const
	Get a slice of an N-dimensional array in a particular cell (i.e.
Array< T >	getSlice (uInt rownr, const Slicer &arraySection) const
void	getSlice (uInt rownr, const Vector< Vector< Slice > > &arraySlices, Array< T > &arr, Bool resize=False) const
	Get an irregular slice of an N-dimensional array in a particular cell (i.e.
Array< T >	getSlice (uInt rownr, const Vector< Vector< Slice > > &arraySlices) const
void	getColumn (Array< T > &array, Bool resize=False) const
	Get the array of all values in a column.
Array< T >	getColumn () const
void	getColumn (const Slicer &arraySection, Array< T > &array, Bool resize=False) const
	Get regular slices from all arrays in the column.
Array< T >	getColumn (const Slicer &arraySection) const
void	getColumn (const Vector< Vector< Slice > > &arraySection, Array< T > &array, Bool resize=False) const
	Get irregular slices from all arrays in the column as given by the vectors of Slice objects.
Array< T >	getColumn (const Vector< Vector< Slice > > &arraySection) const
void	getColumnRange (const Slicer &rowRange, Array< T > &arr, Bool resize=False) const
	Get the array of some values in a column.
Array< T >	getColumnRange (const Slicer &rowRange) const
void	getColumnCells (const RefRows &rownrs, Array< T > &arr, Bool resize=False) const
Array< T >	getColumnCells (const RefRows &rownrs) const
void	getColumnRange (const Slicer &rowRange, const Slicer &arraySection, Array< T > &arr, Bool resize=False) const
	Get slices from some arrays in a column.
Array< T >	getColumnRange (const Slicer &rowRange, const Slicer &arraySection) const
void	getColumnCells (const RefRows &rownrs, const Slicer &arraySection, Array< T > &arr, Bool resize=False) const
Array< T >	getColumnCells (const RefRows &rownrs, const Slicer &arraySection) const
void	getColumnCells (const RefRows &rows, const Vector< Vector< Slice > > &arraySlices, Array< T > &arr, Bool resize=False) const
	Similar to getColumn (arraySlices, arr, resize) except it gets the slices for the given rows instead of all rows.
void	getSliceForRows (const RefRows &rows, const Vector< Vector< Slice > > &arraySlices, Array< T > &destination) const
void	baseGet (uInt rownr, Array< T > &array) const
	The get() function like above which does not check shapes, etc.
void	setShape (uInt rownr, const IPosition &shape)
	Set the shape of the array in the given row.
void	setShape (uInt rownr, const IPosition &shape, const IPosition &tileShape)
	Try to store the array in a tiled way using the given tile shape.
void	put (uInt rownr, const Array< T > &array)
	Put the array in a particular cell (i.e.
void	put (uInt rownr, const ArrayColumn< T > &that)
	Copy the value of a cell of that column to a cell of this column.
void	put (uInt thisRownr, const ArrayColumn< T > &that, uInt thatRownr)
	Use possibly different row numbers for that (i.e.
void	put (uInt rownr, const TableColumn &that)
	Copy the value of a cell of that column to a cell of this column.
void	put (uInt thisRownr, const TableColumn &that, uInt thatRownr)
	Use possibly different row numbers for that (i.e.
void	putSlice (uInt rownr, const Slicer &arraySection, const Array< T > &array)
	Put into a slice of an N-dimensional array in a particular cell.
void	putSlice (uInt rownr, const Vector< Vector< Slice > > &arraySlices, const Array< T > &arr)
void	putColumn (const Array< T > &array)
	Put the array of all values in the column.
void	putColumn (const Slicer &arraySection, const Array< T > &array)
	Put into subsections of the table arrays in the entire column.
void	putColumn (const Vector< Vector< Slice > > &arraySlices, const Array< T > &arr)
void	putColumnRange (const Slicer &rowRange, const Array< T > &arr)
	Put the array of some values in the column.
void	putColumnCells (const RefRows &rownrs, const Array< T > &arr)
void	putColumnRange (const Slicer &rowRange, const Slicer &arraySection, const Array< T > &arr)
	Put into subsection of the table arrays in some rows of the column.
void	putColumnCells (const RefRows &rownrs, const Slicer &arraySection, const Array< T > &arr)
void	putColumnCells (const RefRows &rows, const Vector< Vector< Slice > > &arraySlices, const Array< T > &arr)
	Same as putColumn(arraySlices, arr) except that it puts for the given rows instead of all rows.
void	putSliceFromRows (const RefRows &rows, const Vector< Vector< Slice > > &arraySlices, const Array< T > &source)
void	fillColumn (const Array< T > &value)
	Put the same value in all cells of the column.
void	putColumn (const ArrayColumn< T > &that)
	Put the contents of a column with the same data type into this column.
void	basePut (uInt rownr, const Array< T > &array)
	The put() function like above which does not check shapes, etc.
Protected Member Functions
void	handleSlices (const Vector< Vector< Slice > > &slices, BaseSlicesFunctor< T > &functor, const Slicer &slicer, IPosition &arrEnd, Array< T > &array) const
	A common function used by all functions that can get or put irregular array slices.
Protected Attributes
Bool	canAccessSlice_p
	Keep switches to determine if a slice or an entire column can be accessed or the change of an array can be changed.
Bool	canAccessColumn_p
Bool	canAccessColumnSlice_p
Bool	reaskAccessSlice_p
	Keep switches to know if access knowledge is permanent or has to be asked again the next time.
Bool	reaskAccessColumn_p
Bool	reaskAccessColumnSlice_p
Private Member Functions
void	checkDataType () const
	Check if the data type matches the column data type.
void	checkShape (const IPosition &shp, Array< T > &arr, Bool resize, const String &where) const
	Check the shape of the array.

Detailed Description

template<class T>
class casa::ArrayColumn< T >

Read and write access to an array table column with arbitrary data type.

Intended use:

Public interface

Review Status

Reviewed By:: dschieb
Date Reviewed:: 1994/08/10
Test programs:: none

Prerequisite

Etymology

ArrayColumn<T> gives read and write access to an column in a table containing an array with data type T.

Synopsis

The class ArrayColumn allows readonly access to a column containing arrays with an arbitrary data type. It can handle direct as well as indirect arrays. It is possible to get the data in an individual cell (i.e. table row); either the whole array or a slice of the array can be accessed. It is also possible to get the column as a whole if the arrays in all cells of the column have the same shape (which is always true for direct arrays). As in the case of individual cells it is possible to get the entire arrays or a slice of the arrays.

A default constructor is defined to allow construction of an array of ArrayColumn objects. However, this constructs an object not referencing a column. Functions like get, etc. will fail (i.e. result in a segmentation fault) when used on such objects. The functions isNull and throwIfNull can be used to test on this. The functions attach and reference can fill in the object.

The assignment operator is not defined for this class, because it was felt it would be too confusing. Instead the function reference can be used to do assignment with reference semantics. An assignment with copy semantics makes no sense for a readonly column.

Template Type Argument Requirements (T)

Default constructor
Copy constructor
Assignment operator

Example

See module Tables .

Definition at line 103 of file ArrayColumn.h.

Constructor & Destructor Documentation

template<class T>

casa::ArrayColumn< T >::ArrayColumn ( )

The default constructor creates a null object, i.e.

it does not reference a table column. The sole purpose of this constructor is to allow construction of an array of ArrayColumn objects. The functions reference and attach can be used to make a null object reference a column. Note that get functions, etc. will cause a segmentation fault when operating on a null object. It was felt it was too expensive to test on null over and over again. The user should use the isNull or throwIfNull function in case of doubt.

template<class T>

casa::ArrayColumn< T >::ArrayColumn	(	const Table &	,
		const String &	columnName
	)

Construct for the given column in the given table.

template<class T>

casa::ArrayColumn< T >::ArrayColumn ( const TableColumn & ) [explicit]

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.

template<class T>

casa::ArrayColumn< T >::ArrayColumn ( const ArrayColumn< T > & )

Copy constructor (reference semantics).

template<class T>

casa::ArrayColumn< T >::~ArrayColumn ( )

Member Function Documentation

template<class T>

void casa::ArrayColumn< T >::attach	(	const Table &	table,
		const String &	columnName
	)		`[inline]`

Attach a column to the object.

This is in fact only a shorthand for
reference (ArrayColumn<T> (table, columnName));

Reimplemented from casa::TableColumn.

Definition at line 150 of file ArrayColumn.h.

template<class T>

void casa::ArrayColumn< T >::baseGet	(	uInt	rownr,
		Array< T > &	array
	)		const `[inline]`

The get() function like above which does not check shapes, etc.

It is faster and can be used for performance reasons if one knows for sure that the arguments are correct. E.g. it is used internally in virtual column engines.

Definition at line 345 of file ArrayColumn.h.

template<class T>

void casa::ArrayColumn< T >::basePut	(	uInt	rownr,
		const Array< T > &	array
	)		`[inline]`

The put() function like above which does not check shapes, etc.

It is faster and can be used for performance reasons if one knows for sure that the arguments are correct. E.g. it is used internally in virtual column engines.

Definition at line 468 of file ArrayColumn.h.

template<class T>

void casa::ArrayColumn< T >::checkDataType ( ) const [private]

Check if the data type matches the column data type.

template<class T>

void casa::ArrayColumn< T >::checkShape	(	const IPosition &	shp,
		Array< T > &	arr,
		Bool	resize,
		const String &	where
	)		const `[private]`

Check the shape of the array.

If the array is empty or if resize=True, the array is resized if needed. An exception is thrown if not conforming.

template<class T>

virtual TableColumn* casa::ArrayColumn< T >::clone ( ) const [virtual]

Clone the object.

Reimplemented from casa::TableColumn.

template<class T>

void casa::ArrayColumn< T >::fillColumn ( const Array< T > & value )

Put the same value in all cells of the column.

template<class T>

void casa::ArrayColumn< T >::get	(	uInt	rownr,
		Array< T > &	array,
		Bool	resize = `False`
	)		const

Get the array value in a particular cell (i.e.

table row). The row numbers count from 0 until #rows-1.

According to the assignment rules of class Array, the destination array must be empty or its shape must conform the table array shape. However, if the resize flag is set the destination array will be resized if not conforming.

template<class T>

Array<T> casa::ArrayColumn< T >::get ( uInt rownr ) const

template<class T>

void casa::ArrayColumn< T >::getColumn	(	Array< T > &	array,
		Bool	resize = `False`
	)		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.

According to the assignment rules of class Array, the destination array must be empty or its shape must conform the resulting (n+1)-dim array. However, if the resize flag is set the destination array will be resized if not conforming.

template<class T>

Array<T> casa::ArrayColumn< T >::getColumn ( ) const

template<class T>

void casa::ArrayColumn< T >::getColumn	(	const Slicer &	arraySection,
		Array< T > &	array,
		Bool	resize = `False`
	)		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.

According to the assignment rules of class Array, the destination array must be empty or its shape must conform the resulting (n+1)-dim array. However, if the resize flag is set the destination array will be resized if not conforming.

template<class T>

Array<T> casa::ArrayColumn< T >::getColumn ( const Slicer & arraySection ) const

template<class T>

void casa::ArrayColumn< T >::getColumn	(	const Vector< Vector< Slice > > &	arraySection,
		Array< T > &	array,
		Bool	resize = `False`
	)		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:

        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);

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.

According to the assignment rules of class Array, the destination array must be empty or its shape must conform the resulting (n+1)-dim array. However, if the resize flag is set the destination array will be resized if not conforming.

template<class T>

Array<T> casa::ArrayColumn< T >::getColumn ( const Vector< Vector< Slice > > & arraySection ) const

template<class T>

void casa::ArrayColumn< T >::getColumnCells	(	const RefRows &	rownrs,
		Array< T > &	arr,
		Bool	resize = `False`
	)		const

Referenced by casa::ArrayColumn< Complex >::getSliceForRows().

template<class T>

Array<T> casa::ArrayColumn< T >::getColumnCells ( const RefRows & rownrs ) const

template<class T>

void casa::ArrayColumn< T >::getColumnCells	(	const RefRows &	rownrs,
		const Slicer &	arraySection,
		Array< T > &	arr,
		Bool	resize = `False`
	)		const

template<class T>

Array<T> casa::ArrayColumn< T >::getColumnCells	(	const RefRows &	rownrs,
		const Slicer &	arraySection
	)		const

template<class T>

void casa::ArrayColumn< T >::getColumnCells	(	const RefRows &	rows,
		const Vector< Vector< Slice > > &	arraySlices,
		Array< T > &	arr,
		Bool	resize = `False`
	)		const

Similar to getColumn (arraySlices, arr, resize) except it gets the slices for the given rows instead of all rows.

template<class T>

void casa::ArrayColumn< T >::getColumnRange	(	const Slicer &	rowRange,
		Array< T > &	arr,
		Bool	resize = `False`
	)		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. According to the assignment rules of class Array, the destination array must be empty or its shape must conform the resulting (n+1)-dim array. However, if the resize flag is set the destination array will be resized if not conforming.

template<class T>

Array<T> casa::ArrayColumn< T >::getColumnRange ( const Slicer & rowRange ) const

template<class T>

void casa::ArrayColumn< T >::getColumnRange	(	const Slicer &	rowRange,
		const Slicer &	arraySection,
		Array< T > &	arr,
		Bool	resize = `False`
	)		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. According to the assignment rules of class Array, the destination array must be empty or its shape must conform the resulting (n+1)-dim array. However, if the resize flag is set the destination array will be resized if not conforming.

template<class T>

Array<T> casa::ArrayColumn< T >::getColumnRange	(	const Slicer &	rowRange,
		const Slicer &	arraySection
	)		const

template<class T>

void casa::ArrayColumn< T >::getSlice	(	uInt	rownr,
		const Slicer &	arraySection,
		Array< T > &	array,
		Bool	resize = `False`
	)		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.

According to the assignment rules of class Array, the destination array must be empty or its shape must conform the shape of the table array slice. However, if the resize flag is set the destination array will be resized if not conforming.

template<class T>

Array<T> casa::ArrayColumn< T >::getSlice	(	uInt	rownr,
		const Slicer &	arraySection
	)		const

template<class T>

void casa::ArrayColumn< T >::getSlice	(	uInt	rownr,
		const Vector< Vector< Slice > > &	arraySlices,
		Array< T > &	arr,
		Bool	resize = `False`
	)		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:

        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);

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.

According to the assignment rules of class Array, the destination array must be empty or its shape must conform the resulting (n+1)-dim array. However, if the resize flag is set the destination array will be resized if not conforming.

template<class T>

Array<T> casa::ArrayColumn< T >::getSlice	(	uInt	rownr,
		const Vector< Vector< Slice > > &	arraySlices
	)		const

template<class T>

void casa::ArrayColumn< T >::getSliceForRows	(	const RefRows &	rows,
		const Vector< Vector< Slice > > &	arraySlices,
		Array< T > &	destination
	)		const `[inline]`

Definition at line 336 of file ArrayColumn.h.

template<class T>

void casa::ArrayColumn< T >::handleSlices	(	const Vector< Vector< Slice > > &	slices,
		BaseSlicesFunctor< T > &	functor,
		const Slicer &	slicer,
		IPosition &	arrEnd,
		Array< T > &	array
	)		const `[protected]`

A common function used by all functions that can get or put irregular array slices.

The functor performs the get or put operation.

template<class T>

uInt casa::ArrayColumn< T >::ndim ( uInt rownr ) const [inline]

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.

Reimplemented from casa::TableColumn.

Definition at line 156 of file ArrayColumn.h.

template<class T>

Array<T> casa::ArrayColumn< T >::operator() ( uInt rownr ) const

template<class T>

ArrayColumn<T>& casa::ArrayColumn< T >::operator= ( const ArrayColumn< T > & )

Assignment uses reference semantics, thus works the same as function reference.

template<class T>

void casa::ArrayColumn< T >::put	(	uInt	rownr,
		const Array< T > &	array
	)

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.

template<class T>

void casa::ArrayColumn< T >::put	(	uInt	rownr,
		const ArrayColumn< T > &	that
	)		`[inline]`

Copy the value of a cell of that column to a cell of this column.

The data types of both columns must be the same, otherwise an exception is thrown.

Use the same row numbers for both cells.

Definition at line 370 of file ArrayColumn.h.

Referenced by casa::ArrayColumn< Complex >::put().

template<class T>

void casa::ArrayColumn< T >::put	(	uInt	thisRownr,
		const ArrayColumn< T > &	that,
		uInt	thatRownr
	)

Use possibly different row numbers for that (i.e.

input) and and this (i.e. output) cell.

template<class T>

void casa::ArrayColumn< T >::put	(	uInt	rownr,
		const TableColumn &	that
	)		`[inline]`

Copy the value of a cell of that column to a cell of this column.

This function uses a generic TableColumn object as input. The data types of both columns must be the same, otherwise an exception is thrown.

Use the same row numbers for both cells.

Reimplemented from casa::TableColumn.

Definition at line 383 of file ArrayColumn.h.

Referenced by casa::ArrayColumn< Complex >::put().

template<class T>

void casa::ArrayColumn< T >::put	(	uInt	thisRownr,
		const TableColumn &	that,
		uInt	thatRownr
	)		`[virtual]`

Use possibly different row numbers for that (i.e.

input) and and this (i.e. output) cell.

Reimplemented from casa::TableColumn.

template<class T>

void casa::ArrayColumn< T >::putColumn ( const Array< T > & array )

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.

template<class T>

void casa::ArrayColumn< T >::putColumn	(	const Slicer &	arraySection,
		const Array< T > &	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.

template<class T>

void casa::ArrayColumn< T >::putColumn	(	const Vector< Vector< Slice > > &	arraySlices,
		const Array< T > &	arr
	)

template<class T>

void casa::ArrayColumn< T >::putColumn ( const ArrayColumn< T > & that )

Put the contents of a column with the same data type into this column.

To put the contents of a column with a different data type into this column, the function TableColumn::putColumn can be used (provided the data type promotion is possible). In fact, this function is an assignment operator with copy semantics.

template<class T>

void casa::ArrayColumn< T >::putColumnCells	(	const RefRows &	rownrs,
		const Array< T > &	arr
	)

Referenced by casa::ArrayColumn< Complex >::putSliceFromRows().

template<class T>

void casa::ArrayColumn< T >::putColumnCells	(	const RefRows &	rownrs,
		const Slicer &	arraySection,
		const Array< T > &	arr
	)

template<class T>

void casa::ArrayColumn< T >::putColumnCells	(	const RefRows &	rows,
		const Vector< Vector< Slice > > &	arraySlices,
		const Array< T > &	arr
	)

Same as putColumn(arraySlices, arr) except that it puts for the given rows instead of all rows.

template<class T>

void casa::ArrayColumn< T >::putColumnRange	(	const Slicer &	rowRange,
		const Array< T > &	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.

template<class T>

void casa::ArrayColumn< T >::putColumnRange	(	const Slicer &	rowRange,
		const Slicer &	arraySection,
		const Array< T > &	arr
	)

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.

template<class T>

void casa::ArrayColumn< T >::putSlice	(	uInt	rownr,
		const Slicer &	arraySection,
		const Array< T > &	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.

template<class T>

void casa::ArrayColumn< T >::putSlice	(	uInt	rownr,
		const Vector< Vector< Slice > > &	arraySlices,
		const Array< T > &	arr
	)

template<class T>

void casa::ArrayColumn< T >::putSliceFromRows	(	const RefRows &	rows,
		const Vector< Vector< Slice > > &	arraySlices,
		const Array< T > &	source
	)		`[inline]`

Definition at line 448 of file ArrayColumn.h.

template<class T>

void casa::ArrayColumn< T >::reference ( const ArrayColumn< T > & )

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.

Referenced by casa::ArrayColumn< Complex >::attach().

template<class T>

void casa::ArrayColumn< T >::setShape	(	uInt	rownr,
		const IPosition &	shape
	)

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.

template<class T>

void casa::ArrayColumn< T >::setShape	(	uInt	rownr,
		const IPosition &	shape,
		const IPosition &	tileShape
	)

Try to store the array in a tiled way using the given tile shape.

template<class T>

IPosition casa::ArrayColumn< T >::shape ( uInt rownr ) const [inline]

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.

Reimplemented from casa::TableColumn.

Definition at line 162 of file ArrayColumn.h.

Member Data Documentation

template<class T>

Bool casa::ArrayColumn< T >::canAccessColumn_p [mutable, protected]

Definition at line 495 of file ArrayColumn.h.

template<class T>

Bool casa::ArrayColumn< T >::canAccessColumnSlice_p [mutable, protected]

Definition at line 496 of file ArrayColumn.h.

template<class T>

Bool casa::ArrayColumn< T >::canAccessSlice_p [mutable, protected]

Keep switches to determine if a slice or an entire column can be accessed or the change of an array can be changed.

True = yes; False = no.

Definition at line 494 of file ArrayColumn.h.

template<class T>

Bool casa::ArrayColumn< T >::reaskAccessColumn_p [mutable, protected]

Definition at line 500 of file ArrayColumn.h.

template<class T>

Bool casa::ArrayColumn< T >::reaskAccessColumnSlice_p [mutable, protected]

Definition at line 501 of file ArrayColumn.h.

template<class T>

Bool casa::ArrayColumn< T >::reaskAccessSlice_p [mutable, protected]

Keep switches to know if access knowledge is permanent or has to be asked again the next time.

Definition at line 499 of file ArrayColumn.h.

The documentation for this class was generated from the following file:

casacore/tables/Tables/ArrayColumn.h

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

template<class T> class casa::ArrayColumn< T >

Intended use:

Review Status

Prerequisite

Etymology

Synopsis

Template Type Argument Requirements (T)

Example

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<class T>
class casa::ArrayColumn< T >