/usr/include/casacore/tables/DataMan/VSCEngine.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 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 | //# VSCEngine.h: Base virtual column for a scalar column with any type
//# Copyright (C) 1994,1995,1996,1999,2000
//# 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_VSCENGINE_H
#define TABLES_VSCENGINE_H
//# Includes
#include <casacore/casa/aips.h>
#include <casacore/tables/DataMan/VirtColEng.h>
#include <casacore/tables/DataMan/VirtScaCol.h>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
// <summary>
// Base virtual column for a scalar column with any type
// </summary>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <use visibility=export>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> VirtualColumnEngine
// <li> VirtualScalarColumn
// </prerequisite>
// <etymology>
// VSCEngine stands for Virtual Scalar Column Engine, i.e. a class
// handling a virtual table column containing scalar values.
// </etymology>
// <synopsis>
// VSCEngine is a base virtual column engine to handle a column
// with an arbitrary type.
// Data of columns with standard data types can directly be stored
// in a Table using a storage manager, but data of column with non-standard
// types have to be stored in another way.
// The way to do this is to split the object with the non-standard
// type into its individual elements, which are subsequently put into the
// appropriate columns.
//
// A virtual column engine has to be implemented for each non-standard
// data type, which has to be stored in a table. This engine has to get
// and put the individual parts the object.
// VSCEngine is the base class for such engines, so the actual
// engine quite simple to implement. The example shows the implementation
// of an engine AVSCEngine handling a data type A.
//
// In principle the name of the engine class is free, but it is strongly
// recommended to use the name <src><dataTypeId>VSCEngine</src>, where VSC
// stands for Virtual Scalar Column (e.g. <src>AVSCEngine</src> for class A).
// In this way the default data manager name supplied by the class and by
// class ScalarColumnDesc can be used.
// </synopsis>
// <example>
// This example shows the implementation of an engine class AVSCEngine,
// which stores the data of a class A.
// The data objects A are stored in a column called the source column.
// The user has to associate two target columns with it. The engine stores
// the data parts x and y in the target columns.
// The names of the target columns are stored as keywords in the source
// column. In this way the engine can reconstruct itself when the table
// is read back.
//
// In the example all AVSCEngine functions are shown inline, but they
// should be implemented out-of-line in a separate .cc file.
// <srcblock>
// //# AVSCEngine.h: Example virtual column engine to handle data type A
//
// #if !defined(AIPS_AVSCENGINE_H)
// #define AIPS_AVSCENGINE_H
//
// //# Includes
// #include <casacore/tables/DataMan/VSCEngine.h>
// #include <casacore/tables/Tables/ScalarColumn.h>
//
// // Define the class A.
// class A
// {
// public:
// A(): x_p(0), y_p(0) {}
// A(Int x, float y) : x_p(x), y_p(y) {}
// A(const A& that): x_p(that.x_p), y_p(that.y_p) {}
// static String dataTypeId()
// { return "A"; }
// Int x() const
// { return x_p; }
// float y() const
// { return y_p; }
// Int& x()
// { return x_p; }
// float& y()
// { return y_p; }
// int operator== (const A& that) const
// { return x_p==that.x_p && y_p==that.y_p; }
// int operator< (const A& that) const
// { return x_p<that.x_p || (x_p==that.x_p && y_p<that.y_p); }
// private:
// Int x_p;
// float y_p;
// };
//
// // Now define the engine to handle objects of type A.
// class AVSCEngine : public VSCEngine<A>
// {
// public:
//
// // The default constructor is required for reconstruction of the
// // engine when a table is read back.
// AVSCEngine()
// {}
//
// // Construct the engine for the given source column and storing
// // the result in the given target columns for the data members
// // x and y of class A.
// AVSCEngine (const String& sourceColumnName,
// const String& xTargetColumnName,
// const String& yTargetColumnname)
// : VSCEngine<A> (sourceColumnName),
// xTargetName_p (xTargetColumnName),
// yTargetName_p (yTargetColumnName)
// {}
//
// // Destructor is mandatory.
// virtual ~AVSCEngine()
// {}
//
// // Clone the object.
// virtual DataManager* clone() const
// {
// DataManager* dmPtr = new AVSCEngine (sourceColumnName(),
// xTargetName_p, yTargetName_p);
// return dmPtr;
// }
//
// // Store the target column names in the source column keywords.
// virtual void create (uInt)
// {
// TableColumn src (table(), sourceColumnName());
// src.keywordSet().keysString()("_xTargetName") = xTargetName_p;
// src.keywordSet().keysString()("_yTargetName") = yTargetName_p;
// }
//
// // Prepare the engine by allocating column objects
// // for the target columns.
// virtual void prepare()
// {
// TableColumn src (table(), sourceColumnName());
// xTargetName_p = src.keywordSet().asString ("_xTargetName");
// yTargetName_p = src.keywordSet().asString ("_yTargetName");
// rocolx.attach (table(), xTargetName_p);
// rocoly.attach (table(), yTargetName_p);
// if (table().isWritable()) {
// colx.attach (table(), xTargetName_p);
// coly.attach (table(), yTargetName_p);
// }
// }
//
// // Get the data from a row.
// virtual void get (uInt rownr, A& value)
// {
// rocolx.get (rownr, value.x());
// rocoly.get (rownr, value.y());
// }
//
// // Put the data in a row.
// virtual void put (uInt rownr, const A& value)
// {
// colx.put (rownr, value.x());
// coly.put (rownr, value.y());
// }
//
// // Register the class name and the static makeObject "constructor".
// // This will make the engine known to the table system.
// static void registerClass()
// {
// DataManager::registerCtor ("AVSCEngine", makeObject);
// }
//
// private:
// // Copy constructor is only used by clone().
// // (so it is made private).
// AVSCEngine (const AVSCEngine&)
// : VSCEngine<A> (that),
// xTargetName_p (that.xTargetName_p),
// yTargetName_p (that.yTargetName_p)
// {}
//
// // Assignment is not needed and therefore forbidden
// // (so it is made private and is not implemented).
// AVSCEngine& operator= (const AVSCEngine&);
//
//
// // The target column names.
// String xTargetName_p;
// String yTargetName_p;
// // Objects for the target columns.
// ScalarColumn<Int> colx; // used by put
// ScalarColumn<Int> rocolx; // used by get
// ScalarColumn<float> coly; // used by put
// ScalarColumn<float> rocoly; // used by get
//
// public:
// // Define the "constructor" to construct this engine when a
// // table is read back.
// // This "constructor" has to be registered by the user of the engine.
// // Function registerClass() is doing that.
// static DataManager* makeObject (const String& dataManagerType)
// {
// DataManager* dmPtr = new AVSCEngine();
// return dmPtr;
// }
// };
//
// #endif
// </srcblock>
//
// User code using this engine to create a new table could look like:
// <srcblock>
// // Register the engine.
// // This is not needed if the engine is registered as part
// // of the general DataManager::registerAllCtor function.
// AVSCEngine::registerClass();
// // Create the table description.
// TableDesc td;
// td.addColumn (ScalarColumnDesc<A>("source"));
// td.addColumn (ScalarColumnDesc<Int>("xTarget"));
// td.addColumn (ScalarColumnDesc<Int>("yTarget"));
// SetupNewTable setup ("table.name", td, Table::New);
// // Define the engine for column "source".
// AVSCEngine engine ("source", "xTarget", "yTarget");
// Table tab (setup, 10);
// // Put data into column "source".
// ScalarColumn<A> col (tab, "source");
// for (uInt i=0; i<10; i++) {
// col.put (i, someA); // writes indirectly xTarget and yTarget
// }
// </srcblock>
// </example>
//
// <motivation>
// This class makes it easier for the user to implement the engine.
// It supplies several default functions.
// </motivation>
// <templating arg=T>
// <li> Default constructor T();
// <li> Copy constructor T(const T&);
// <li> Assignment operator T& operator= (const T&);
// <li> comparison operator int operator== (const T&) const;
// <li> comparison operator int operator< (const T&) const;
// <li> identification <src>static String dataTypeId();</src>
// This should return the (unique) name of the class, thus
// when T is templated in its turn, the name should contain the
// template argument name.
// </templating>
template<class T>
class VSCEngine : public VirtualColumnEngine,
public VirtualScalarColumn<T>
{
//# Make members of parent class known.
public:
using VirtualScalarColumn<T>::dataTypeId;
public:
// The default constructor is required for reconstruction of the
// engine when a table is read back.
// It is also used to construct an engine, which does not check
// the source column name.
VSCEngine();
// Construct an engine to handle a column with an arbitrary data type.
// Later it will check if the source column name is correct.
VSCEngine (const String& sourceColumnName);
// Destructor is mandatory.
~VSCEngine();
// Return the data manager type name.
// This defaults to the data type ID followed by VSCEngine
// (meaning Virtual Scalar Column Engine).
String dataManagerType() const;
// Get the name of the source column.
const String& sourceColumnName() const
{ return sourceName_p; }
protected:
// Copy constructor is only used by clone().
// (so it is made protected).
VSCEngine (const VSCEngine<T>&);
private:
// Assignment is not needed and therefore forbidden
// (so it is made private).
VSCEngine<T>& operator= (const VSCEngine<T>&);
// The column is in principle writable.
// This does not mean it is actually writable, because that
// depends on the fact if the table is writable.
Bool isWritable() const;
// Create the column object for the scalar column in this engine.
// It will check if the given column name matches the source
// column name. This assures that the engine is bound to the
// correct column.
DataManagerColumn* makeScalarColumn (const String& columnName,
int dataType,
const String& dataTypeID);
//# Now define the data members.
String sourceName_p; //# source column name
};
} //# NAMESPACE CASACORE - END
#ifndef CASACORE_NO_AUTO_TEMPLATES
#include <casacore/tables/DataMan/VSCEngine.tcc>
#endif //# CASACORE_NO_AUTO_TEMPLATES
#endif
|