/usr/include/casacore/tables/Tables/ConcatColumn.h is in casacore-dev 2.2.0-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 | //# ConcatColumn.h: A column in a concatenated table
//# Copyright (C) 2008
//# 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_CONCATCOLUMN_H
#define TABLES_CONCATCOLUMN_H
//# Includes
#include <casacore/casa/aips.h>
#include <casacore/tables/Tables/BaseColumn.h>
#include <casacore/tables/Tables/ColumnCache.h>
#include <casacore/tables/Tables/TableRecord.h>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
//# Forward Declarations
class ConcatTable;
class BaseColumnDesc;
class TableRecord;
class Slicer;
class IPosition;
template<class T> class Vector;
// <summary>
// A column in a concatenated table
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> ConcatTable
// <li> BaseColumn
// </prerequisite>
// <etymology>
// ConcatTable represents a column in a ConcatTable. A ConcatTable is a table
// referencing another table, usually as the result of a select, etc..
// </etymology>
// <synopsis>
// ConcatColumn handles the access of a column in a ConcatTable.
// 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 ConcatColumn 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 ConcatColumn : public BaseColumn
{
public:
// Construct the ConcatColumn. It will point to the given column
// description, ConcatTable and referenced column.
// The ConcatTable will be used to convert the rownr to the rownr
// in the referenced column.
ConcatColumn (const BaseColumnDesc*, ConcatTable*);
~ConcatColumn();
// 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.
// The initial keyword set is a copy of the keyword set of the first table.
// <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;
// 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);
// 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 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 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 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);
// Allocate value buffers for the table iterator.
// Also get a comparison function 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);
private:
// Define the function to handle access to an entire column.
typedef void AccessColumnFunc (BaseColumn* col,
const Slicer*, ArrayBase* array);
// Define the function to handle access to a number of rows.
typedef void AccessRowsFunc (BaseColumn* col, const RefRows& rows,
const Slicer*, ArrayBase* array);
// Access the data for an entire column.
void accessColumn (const Slicer* ns,
void* dataPtr,
AccessColumnFunc*) const;
// Access the data with multiple rows combined.
void accessRows (const RefRows& rownrs,
const Slicer* ns,
void* dataPtr,
AccessRowsFunc*) const;
// Define the access functions.
static void getColumnPart (BaseColumn* col,
const Slicer*, ArrayBase* arr);
static void putColumnPart (BaseColumn* col,
const Slicer*, ArrayBase* arr);
static void getColumnSlicePart (BaseColumn* col,
const Slicer* ns, ArrayBase* arr);
static void putColumnSlicePart (BaseColumn* col,
const Slicer* ns, ArrayBase* arr);
static void getRowsPart (BaseColumn* col, const RefRows& rows,
const Slicer*, ArrayBase* array);
static void putRowsPart (BaseColumn* col, const RefRows& rows,
const Slicer*, ArrayBase* array);
static void getRowsSlicePart (BaseColumn* col, const RefRows& rows,
const Slicer*, ArrayBase* array);
static void putRowsSlicePart (BaseColumn* col, const RefRows& rows,
const Slicer*, ArrayBase* array);
// </group>
protected:
// Set the column cache to the cache of the given table.
// The row numbers will be adjusted as needed.
void setColumnCache (uInt tableNr, const ColumnCache&) const;
//# Data members
ConcatTable* refTabPtr_p;
Block<BaseColumn*> refColPtr_p;
mutable ColumnCache colCache_p;
TableRecord keywordSet_p;
};
} //# NAMESPACE CASACORE - END
#endif
|