Addition and deletion of rows is allowed, but the functions addRow and removeRow do not do anything at all. They are implemented to override the default "throw exception" implementation. Because the engine allows this, it can be used in a table supporting addition and removal of rows.
An object of this class is created (and deleted) by ForwardColumnEngine which creates a ForwardColumn object for each column being forwarded.
Destructor is mandatory.
Define the special keyword containing the name of the original table. If the column in the referenced table contains that special keyword, it is in its turn a forwarding column. In that case the special keyword value will be copied over to shortcut the forwarding chain. The suffix is appended to the keyword name when defining it. This makes this function usable for derived classes.
Initialize the object. This means binding the column to the column with the same name in the original table. It checks if the description of both columns is the same. It also determines if the column is writable.
Set the column to writable if its underlying table is writable.
Assignment is not needed and therefore forbidden (so make it private).
Create a SetupNewTable object with the given name and option and with the description from the given table. The SetupNewTable object will use a single ForwardColumn engine which forwards all columns to the given table. Later the SetupNewTable::bind functions can be used to bind one or more columns to another data manager.
This data manager may be able to handle changing array shapes.
This data manager may be able to do get/putScalarColumn.
This data manager may be able to do get/putArrayColumn.
This data manager may be able to do get/putSlice.
This data manager may be able to do get/putColumnSlice.
Get the data type of the column as defined in DataType.h.
Get the data type id of the column for dataType==TpOther. This function is required for virtual column engines handling non-standard data types. It is used to check the data type.
Test if data can be put into this column.
Set the shape of an direct array. This only checks if the shape matches the referenced column.
Set the shape of an (indirect) array in the given row.
Is the value shape defined in the given row?
Get the dimensionality of the item in the given row.
Get the shape of the item in the given row.
Get the scalar value with a standard data type in the given row.
Get the scalar value with a non-standard data type in the given row.
Put the scalar value with a standard data type into the given row.
Put the scalar value with a non-standard data type into the given row.
Get all scalar values in the column.
The argument dataPtr is in fact a Vector
Put all scalar values in the column.
The argument dataPtr is in fact a const Vector
Get the array value in the given row.
The argument dataPtr is in fact a Array
Put the array value into the given row.
The argument dataPtr is in fact a const Array
Get a section of the array in the given row.
The argument dataPtr is in fact a Array
Put into a section of the array in the given row.
The argument dataPtr is in fact a const Array
Get all scalar values in the column.
The argument dataPtr is in fact a Vector
Put all scalar values in the column.
The argument dataPtr is in fact a const Vector
Get a section of all arrays in the column.
The argument dataPtr is in fact a Array
Put a section into all arrays in the column.
The argument dataPtr is in fact a const Array
Create the engine.
The columns using this engine will reference the given table.
The data manager gets the given name.
Create the engine.
The columns using this engine will reference the given table.
The data manager has no name.
Destructor is mandatory.
Clone the engine object.
Return the name of the data manager. This is the name of this
instantiation of the data manager, thus not its type name.
Return the type of the engine (i.e. its class name ForwardColumnEngine).
Record a record containing data manager specifications.
Get the suffix to be used for names.
Register the class name and the static makeObject "constructor".
This will make the engine known to the table system.
Add a ForwardColumn object to the block.
Get access to the refTable_p data member.
Do the creation (i.e. initialization) of the engine.
Do the preparation of the engine by preparing all columns.
Assignment is forbidden (so it is private).
This data manager allows to add rows.
This data manager allows to delete rows.
Add rows to all columns.
This is not doing anything (but needed to override the default).
Delete a row from all columns.
This is not doing anything (but needed to override the default).
This data manager allows to add columns.
This data manager allows to delete columns.
Add a column.
Delete a column.
Create the column object for the scalar column in this engine.
Create the column object for the indirect array column in this engine.
Initialize the object for a new table.
It defines the column keywords containing the name of the
original table, which can be the parent of the referenced table.
Initialize the engine.
It gets the name of the original table(s) from the column keywords,
opens those tables and attaches the ForwardColumn objects to the
columns in those tables.
Reopen the engine for read/write access.
It makes all its columns writable if their underlying table is writable.
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.
If the engine is commonly used, its registration can be added
into the registerAllCtor function in DataManReg.cc.
This function gets automatically invoked by the table system.
void putScalarColumnV (const void* dataPtr)
void getArrayV (uInt rownr, void* dataPtr)
void putArrayV (uInt rownr, const void* dataPtr)
void getSliceV (uInt rownr, const Slicer& slicer, void* dataPtr)
void putSliceV (uInt rownr, const Slicer& slicer, const void* dataPtr)
void getArrayColumnV (void* dataPtr)
void putArrayColumnV (const void* dataPtr)
void getColumnSliceV (const Slicer& slicer, void* dataPtr)
void putColumnSliceV (const Slicer& slicer, const void* dataPtr)
class ForwardColumnEngine : public VirtualColumnEngine
Interface
Description
Review Status
Prerequisite
Synopsis
ForwardColumnEngine is a data manager which forwards
the gets and puts of columns to columns with the same names in
another table.
It is, in fact, a reference to the other table columns.
The engine consists of a set of
ForwardColumn
objects, which handle the actual gets and puts.
Motivation
This class will be used by the calibration software.
Most columns in a measurement table will be forwarded
(thus bound to a ForwardColumnEngine object), while
a few (i.e. the data themselves) will be calculated by a dedicated
calibration engine.
Example
// The original table.
Table tab("someTable");
// Create another table with the same description.
SetupNewTable newtab("tForwardCol1.data", tab.tableDesc(), Table::New);
// Create an engine which forwards to the original table.
// Bind all columns in the new table to the forwarding engine.
ForwardColumnEngine fce(tab);
newtab.bindAll (fce);
// Create the new table.
// Every get and put on this table is forwarded to the original table.
// NB. Puts cannot be done here, because the original table was
// opened as readonly.
// Of course, some columns could have been bound to another
// data manager (storage manager, calibration engine, ...).
Table forwTab(newtab);
Member Description
ForwardColumnEngine (const String& dataManagerName, const Record& spec)
The default constructor is required for reconstruction of the
engine when a table is read back.
ForwardColumnEngine (const Table& referencedTable, const String& dataManagerName)
ForwardColumnEngine (const Table& referencedTable)
~ForwardColumnEngine()
DataManager* clone() const
String dataManagerName() const
String dataManagerType() const
virtual Record dataManagerSpec() const
const String& suffix() const
static void registerClass()
void setSuffix (const String& suffix)
Set the suffix.
void addForwardColumn (ForwardColumn* colp)
const Table& refTable() const
void baseCreate()
void basePrepare()
ForwardColumnEngine (const ForwardColumnEngine&)
The copy constructor is forbidden (so it is private).
ForwardColumnEngine& operator= (const ForwardColumnEngine&)
Bool canAddRow() const
Bool canRemoveRow() const
void addRow (uInt nrrow)
void removeRow (uInt rownr)
Bool canAddColumn() const
Bool canRemoveColumn() const
void addColumn (DataManagerColumn*)
void removeColumn (DataManagerColumn*)
DataManagerColumn* makeScalarColumn (const String& columnName, int dataType, const String& dataTypeId)
DataManagerColumn* makeIndArrColumn (const String& columnName, int dataType, const String& dataTypeId)
void create (uInt initialNrrow)
void prepare()
void reopenRW()
void setRefTable (const Table& refTable)
Set RefTable_p if not set yet.
This is done by ForwardColumn to cover the case for existing
tables where the default constructor of ForwardColumnEngine
is used and refTable_p is not filled in.
static DataManager* makeObject (const String& dataManagerType, const Record& spec)