Loading...
Searching...
No Matches
VirtColEng.h
Go to the documentation of this file.
//# VirtColEng.h: Abstract base class for virtual column handling
//# Copyright (C) 1994,1995,1996,1997,1999,2001
//# 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_VIRTCOLENG_H
#define TABLES_VIRTCOLENG_H
//# Includes
#include <casacore/casa/aips.h>
#include <casacore/tables/DataMan/DataManager.h>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
//# Forward Declarations
// <summary>
// Abstract base class for virtual column handling
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> DataManager
// <li> Table
// </prerequisite>
// <etymology>
// VirtualColumnEngine is the abstract data manager class for specialized
// classes (engines) handling a group of virtual columns.
// </etymology>
// <synopsis>
// VirtualColumnEngine is the data manager for classes handling
// a group of virtual columns in tables. It is an abstract base class
// for the specialized virtual column engines.
// Each virtual column as such is represented by a class which has
// to be derived from the abstract base classes VirtualScalarColumn
// or VirtualArrayColumn. The engine has to create the various
// column objects via the functions makeXXXColumn.
//
// Initialization of the virtual column engine is done by the
// functions create (for new tables), open (for existing tables) and prepare.
// The engine can be flushed by the function flush, which allows to
// write some data. The function open can read these data back.
// VirtualColumnEngine is closely related with the table system.
//
// A number of (pure) virtual functions have been defined. The pure
// virtual functions must be implemented in the derived class.
// The non-pure virtual functions have a default implementation throwing
// a "not possible" exception. They need to be implemented if they
// are used for this engine (e.g. makeIndArrColumn does not need to
// be implemented if the engine does not handle arrays).
// Furthermore the pure virtual function dataManagerType (defined in
// DataManager.h) has to be implemented. This should return the name
// of the data manager, which is usually its class name. This name
// has to be unique; so if the engine is templated, the template
// parameter has to be part of the data manager name.
//
// The engine has to be registered before it can be used by the table system.
// This means that a special makeObject function has to be made
// known to the table system, which allows the table system to
// reconstruct the engine using its name.
//
// An example of a virtual column engine can be found in dVirtColEng.{h,cc}
// in the test directory of the Tables module.
// Another exanple is class ScaledComplexData.
// </synopsis>
// <motivation>
// It is nice if a table column can be expressed as a function
// of other columns (maybe even in other tables). A virtual column
// provides this functionality in a very flexible way.
// A specialized class can calculate the data of a virtual column,
// but a common base class is required to interface it to the
// table system.
// </motivation>
// <todo asof="$DATE:$">
//# A List of bugs, limitations, extensions or planned refinements.
// </todo>
class VirtualColumnEngine : public DataManager
{
public:
// Create the object.
VirtualColumnEngine()
{};
virtual ~VirtualColumnEngine();
// The copy constructor cannot be used for this base class.
// The clone function should be used instead.
VirtualColumnEngine (const VirtualColumnEngine&) = delete;
// Assignment cannot be used for this base class.
VirtualColumnEngine& operator= (const VirtualColumnEngine&) = delete;
private:
// The data manager is not a storage manager?
virtual Bool isStorageManager() const;
// Does the data manager allow to add rows? (default no)
virtual Bool canAddRow() const;
// Does the data manager allow to delete rows? (default no)
virtual Bool canRemoveRow() const;
// Add rows to all columns.
// The default implementation does nothing.
virtual void addRow64 (rownr_t nrrow);
// Delete a row from all columns.
// The default implementation does nothing.
virtual void removeRow64 (rownr_t rownr);
// Flush the data in the engine object.
// If the object contains persistent data, this is the place to write them.
// This can be done in two ways:
// <ul>
// <li>
// They can be written in the main table file (using the AipsIO argument).
// This should preferably be used if the object contains only little data.
// <li>
// They can be written in a file of its own. A unique filename
// can be acquired using DataManager::fileName().
// This way is preferred when the object contains a lot of data.
// Possibly this file could already be created in function create
// and only be flushed and closed in this function. This allows
// getting and putting of data as needed.
// </ul>
// Another way of storing information is by storing it as a keyword
// in the table. In this case it is important to know that close
// is called AFTER the keywords are written. Thus, in this way the
// information has to be stored and read back in create, open and/or
// prepare.
// It returns a True status if it had to flush (i.e. if data have changed).
// <br>The default implementation does nothing and returns False.
virtual Bool flush (AipsIO&, Bool fsync);
// Resync the storage manager with the new file contents.
// This is done by clearing the cache.
// The default implementation does nothing.
virtual rownr_t resync64 (rownr_t nrrow);
// Initialize the object for a new table containing initially nrrow rows.
// It can be used to initialize variables (possibly using data
// from other columns in the table).
// The default implementation does nothing.
virtual void create64 (rownr_t initialNrrow);
// Initialize the object for an existing table containing nrrow rows.
// It can be used to read values back (written by close) and/or
// to initialize variables (possibly using data from other columns
// in the table).
// The default implementation does nothing.
virtual rownr_t open64 (rownr_t nrrow, AipsIO& mainTableFile);
// Let the data manager initialize itself further.
// Prepare is called after create/open has been called for all
// columns. In this way one can be sure that referenced columns
// are read back and partly initialized.
// The default implementation does nothing.
virtual void prepare();
// The data manager will be deleted (because all its columns are
// requested to be deleted).
// So clean up the things needed (e.g. delete files).
// By default it assumes that nothing has to be done.
virtual void deleteManager();
// Make a column object in the engine on behalf of a table column.
// This column object class is derived from VirtualScalarColumn
// or VirtualArrayColumn. It handles the gets and puts of data.
// <group>
// Create a scalar column.
// The default implementation throws an exception that it cannot
// do it for this column.
virtual DataManagerColumn* makeScalarColumn (const String& columnName,
int dataType,
const String& dataTypeId);
// Create a direct array column.
// The default implementation calls makeIndArrColumn
// (when reading the user sees no difference between direct and indirect).
virtual DataManagerColumn* makeDirArrColumn (const String& columnName,
int dataType,
const String& dataTypeId);
// Create an indirect array column.
// The default implementation throws an exception that it cannot
// do it for this column.
virtual DataManagerColumn* makeIndArrColumn (const String& columnName,
int dataType,
const String& dataTypeId);
// </group>
};
} //# NAMESPACE CASACORE - END
#endif
casacore::AipsIO
Definition AipsIO.h:167
casacore::DataManagerColumn
Definition DataManagerColumn.h:149
casacore::DataManager::DataManager
DataManager()
Default constructor.
casacore::String
String: the storage and methods of handling collections of characters.
Definition String.h:223
casacore::VirtualColumnEngine::prepare
virtual void prepare()
Let the data manager initialize itself further.
casacore::VirtualColumnEngine::makeScalarColumn
virtual DataManagerColumn * makeScalarColumn(const String &columnName, int dataType, const String &dataTypeId)
Make a column object in the engine on behalf of a table column.
casacore::VirtualColumnEngine::~VirtualColumnEngine
virtual ~VirtualColumnEngine()
casacore::VirtualColumnEngine::operator=
VirtualColumnEngine & operator=(const VirtualColumnEngine &)=delete
Assignment cannot be used for this base class.
casacore::VirtualColumnEngine::VirtualColumnEngine
VirtualColumnEngine()
Create the object.
Definition VirtColEng.h:114
casacore::VirtualColumnEngine::flush
virtual Bool flush(AipsIO &, Bool fsync)
Flush the data in the engine object.
casacore::VirtualColumnEngine::canRemoveRow
virtual Bool canRemoveRow() const
Does the data manager allow to delete rows?
casacore::VirtualColumnEngine::open64
virtual rownr_t open64(rownr_t nrrow, AipsIO &mainTableFile)
Initialize the object for an existing table containing nrrow rows.
casacore::VirtualColumnEngine::isStorageManager
virtual Bool isStorageManager() const
The data manager is not a storage manager?
casacore::VirtualColumnEngine::deleteManager
virtual void deleteManager()
The data manager will be deleted (because all its columns are requested to be deleted).
casacore::VirtualColumnEngine::makeIndArrColumn
virtual DataManagerColumn * makeIndArrColumn(const String &columnName, int dataType, const String &dataTypeId)
Create an indirect array column.
casacore::VirtualColumnEngine::removeRow64
virtual void removeRow64(rownr_t rownr)
Delete a row from all columns.
casacore::VirtualColumnEngine::resync64
virtual rownr_t resync64(rownr_t nrrow)
Resync the storage manager with the new file contents.
casacore::VirtualColumnEngine::makeDirArrColumn
virtual DataManagerColumn * makeDirArrColumn(const String &columnName, int dataType, const String &dataTypeId)
Create a direct array column.
casacore::VirtualColumnEngine::addRow64
virtual void addRow64(rownr_t nrrow)
Add rows to all columns.
casacore::VirtualColumnEngine::create64
virtual void create64(rownr_t initialNrrow)
Initialize the object for a new table containing initially nrrow rows.
casacore::VirtualColumnEngine::VirtualColumnEngine
VirtualColumnEngine(const VirtualColumnEngine &)=delete
The copy constructor cannot be used for this base class.
casacore::VirtualColumnEngine::canAddRow
virtual Bool canAddRow() const
Does the data manager allow to add rows?
casacore
this file contains all the compiler specific defines
Definition mainpage.dox:28
casacore::Bool
bool Bool
Define the standard types used by Casacore.
Definition aipstype.h:40
casacore::rownr_t
uInt64 rownr_t
Define the type of a row number in a table.
Definition aipsxtype.h:44
casacore::dataType
DataType dataType(const RecordFieldId &) const