1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
|
//# RefColumn.h: A column in a reference table
//# Copyright (C) 1994,1995,1996,1997,1998
//# 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: aips2-request@nrao.edu.
//# Postal address: AIPS++ Project Office
//# National Radio Astronomy Observatory
//# 520 Edgemont Road
//# Charlottesville, VA 22903-2475 USA
//#
//# $Id$
#ifndef TABLES_REFCOLUMN_H
#define TABLES_REFCOLUMN_H
//# Includes
#include <casacore/casa/aips.h>
#include <casacore/tables/Tables/BaseColumn.h>
#include <casacore/tables/Tables/ColumnCache.h>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
//# Forward Declarations
class RefTable;
class BaseColumnDesc;
class TableRecord;
class Slicer;
class IPosition;
template<class T> class Vector;
// <summary>
// A column in a reference table
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> RefTable
// <li> BaseColumn
// </prerequisite>
// <etymology>
// RefTable represents a column in a RefTable. A RefTable is a table
// referencing another table, usually as the result of a select, etc..
// </etymology>
// <synopsis>
// RefColumn handles the access of a column in a RefTable.
// It calls the corresponding function in the referenced column
// while converting the given row number to the row number in the
// referenced table.
// </synopsis>
// <motivation>
// This class is untyped, i.e. not templated.
// Every call is sent to the underlying referenced BaseColumn which
// is typed by the virtual function mechanism.
// A RefColumn can never be used directly. A user always has to
// construct a typed ArrayColumn or ScalarColumn object to access a column.
// This means everyting is fully type safe.
// </motivation>
// <todo asof="$DATE:$">
//# A List of bugs, limitations, extensions or planned refinements.
// <li> Act upon removal of rows or the underlying column
// </todo>
class RefColumn : public BaseColumn
{
public:
// Construct the RefColumn. It will point to the given column
// description, RefTable and referenced column.
// The RefTable will be used to convert the rownr to the rownr
// in the referenced column.
RefColumn (const BaseColumnDesc*, RefTable*, BaseColumn* referencedColumn);
~RefColumn();
// Test if the column is writable in the parent table.
virtual Bool isWritable() const;
// Test if the column is stored (otherwise it is virtual).
virtual Bool isStored() const;
// Get access to the column keyword set.
// This is the keyword set in the referenced column.
// <group>
virtual TableRecord& rwKeywordSet();
virtual TableRecord& keywordSet();
// </group>
// Get nr of rows in the column.
virtual uInt nrow() const;
// Test if a value in a particular cell has been defined.
virtual Bool isDefined (uInt rownr) const;
// Set the shape of the array in the given row.
virtual void setShape (uInt rownr, const IPosition& shape);
// Set the shape and tile shape of the array in the given row.
virtual void setShape (uInt rownr, const IPosition& shape,
const IPosition& tileShape);
// Get the global #dimensions of an array (i.e. for all rows).
virtual uInt ndimColumn() const;
// Get the global shape of an array (i.e. for all rows).
virtual IPosition shapeColumn() const;
// Get the #dimensions of an array in a particular cell.
virtual uInt ndim (uInt rownr) const;
// Get the shape of an array in a particular cell.
virtual IPosition shape (uInt rownr) const;
// It can change shape if the underlying column can.
virtual Bool canChangeShape() const;
// It can handle a scalar column if the underlying column
// can handle cells in a scalar column.
virtual Bool canAccessScalarColumn (Bool& reask) const;
// It can handle an array column if the underlying column
// can handle cells in an array column.
virtual Bool canAccessArrayColumn (Bool& reask) const;
// It can handle a cell slice if the underlying column can do it.
virtual Bool canAccessSlice (Bool& reask) const;
// It can handle a column slice if the underlying column
// can handle a collection of cells in a column and a column slice.
virtual Bool canAccessColumnSlice (Bool& reask) const;
// It can handle cells in a scalar column if the underlying column
// can do it.
virtual Bool canAccessScalarColumnCells (Bool& reask) const;
// It can handle cells in an array column if the underlying column
// can do it.
virtual Bool canAccessArrayColumnCells (Bool& reask) const;
// Initialize the rows from startRownr till endRownr (inclusive)
// with the default value defined in the column description (if defined).
void initialize (uInt startRownr, uInt endRownr);
// Get the value from a particular cell.
// This can be a scalar or an array.
virtual void get (uInt rownr, void* dataPtr) const;
// Get a slice of an N-dimensional array in a particular cell.
virtual void getSlice (uInt rownr, const Slicer&, void* dataPtr) const;
// Get the vector of all scalar values in a column.
virtual void getScalarColumn (void* dataPtr) const;
// Get the array of all array values in a column.
// If the column contains n-dim arrays, the resulting array is (n+1)-dim.
// The arrays in the column have to have the same shape in all cells.
virtual void getArrayColumn (void* dataPtr) const;
// Get subsections from all arrays in the column.
// If the column contains n-dim arrays, the resulting array is (n+1)-dim.
// The arrays in the column have to have the same shape in all cells.
virtual void getColumnSlice (const Slicer&, void* dataPtr) const;
// Get the vector of some scalar values in a column.
virtual void getScalarColumnCells (const RefRows& rownrs,
void* dataPtr) const;
// Get the array of some array values in a column.
// If the column contains n-dim arrays, the resulting array is (n+1)-dim.
// The arrays in the column have to have the same shape in all cells.
virtual void getArrayColumnCells (const RefRows& rownrs,
void* dataPtr) const;
// Get subsections from some arrays in the column.
// If the column contains n-dim arrays, the resulting array is (n+1)-dim.
// The arrays in the column have to have the same shape in all cells.
virtual void getColumnSliceCells (const RefRows& rownrs,
const Slicer&, void* dataPtr) const;
// Put the value in a particular cell.
// This can be a scalar or an array.
virtual void put (uInt rownr, const void* dataPtr);
// Put a slice of an N-dimensional array in a particular cell.
virtual void putSlice (uInt rownr, const Slicer&, const void* dataPtr);
// Put the vector of all scalar values in the column.
virtual void putScalarColumn (const void* dataPtr);
// Put the array of all array values in the column.
// If the column contains n-dim arrays, the source array is (n+1)-dim.
// The arrays in the column have to have the same shape in all cells.
virtual void putArrayColumn (const void* dataPtr);
// Put into subsections of all table arrays in the column.
// If the column contains n-dim arrays, the source array is (n+1)-dim.
// The arrays in the column have to have the same shape in all cells.
virtual void putColumnSlice (const Slicer&, const void* dataPtr);
// Get the vector of some scalar values in a column.
virtual void putScalarColumnCells (const RefRows& rownrs,
const void* dataPtr);
// Get the array of some array values in a column.
// If the column contains n-dim arrays, the resulting array is (n+1)-dim.
// The arrays in the column have to have the same shape in all cells.
virtual void putArrayColumnCells (const RefRows& rownrs,
const void* dataPtr);
// Put subsections of some arrays in the column.
// If the column contains n-dim arrays, the source array is (n+1)-dim.
// The arrays in the column have to have the same shape in all cells.
virtual void putColumnSliceCells (const RefRows& rownrs,
const Slicer&, const void* dataPtr);
// Get the underlying column cache.
virtual ColumnCache& columnCache();
// Set the maximum cache size (in bytes) to be used by a storage manager.
virtual void setMaximumCacheSize (uInt nbytes);
// Add this column and its data to the Sort object.
// It may allocate some storage on the heap, which will be saved
// in the argument dataSave.
// The function freeSortKey must be called to free this storage.
virtual void makeSortKey (Sort&, CountedPtr<BaseCompare>& cmpObj,
Int order, const void*& dataSave);
// Free storage on the heap allocated by makeSortkey().
// The pointer will be set to zero.
virtual void freeSortKey (const void*& dataSave);
// Allocate value buffers for the table iterator.
// Also get a comparison functiuon if undefined.
// The function freeIterBuf must be called to free the buffers.
virtual void allocIterBuf (void*& lastVal, void*& curVal,
CountedPtr<BaseCompare>& cmpObj);
// Free the value buffers allocated by allocIterBuf.
virtual void freeIterBuf (void*& lastVal, void*& curVal);
protected:
RefTable* refTabPtr_p;
BaseColumn* colPtr_p;
ColumnCache colCache_p;
};
} //# NAMESPACE CASACORE - END
#endif
|