casacore
Loading...
Searching...
No Matches
MappedArrayEngine.h
Go to the documentation of this file.
1//# MappedArrayEngine.h: Templated virtual column engine to map a table array
2//# Copyright (C) 2005
3//# Associated Universities, Inc. Washington DC, USA.
4//#
5//# This library is free software; you can redistribute it and/or modify it
6//# under the terms of the GNU Library General Public License as published by
7//# the Free Software Foundation; either version 2 of the License, or (at your
8//# option) any later version.
9//#
10//# This library is distributed in the hope that it will be useful, but WITHOUT
11//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12//# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
13//# License for more details.
14//#
15//# You should have received a copy of the GNU Library General Public License
16//# along with this library; if not, write to the Free Software Foundation,
17//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
18//#
19//# Correspondence concerning AIPS++ should be addressed as follows:
20//# Internet email: aips2-request@nrao.edu.
21//# Postal address: AIPS++ Project Office
22//# National Radio Astronomy Observatory
23//# 520 Edgemont Road
24//# Charlottesville, VA 22903-2475 USA
25//#
26//# $Id$
27
28#ifndef TABLES_MAPPEDARRAYENGINE_H
29#define TABLES_MAPPEDARRAYENGINE_H
30
31//# Includes
32#include <casacore/casa/aips.h>
33#include <casacore/tables/DataMan/BaseMappedArrayEngine.h>
34
35namespace casacore { //# NAMESPACE CASACORE - BEGIN
36
37
38// <summary>
39// Templated virtual column engine to map the data type of a table array
40// </summary>
41
42// <use visibility=export>
43
44// <reviewed reviewer="Gareth Hunt" date="94Nov17" tests="">
45// </reviewed>
46
47// <prerequisite>
48//# Classes you should understand before using this one.
49// <li> VirtualColumnEngine
50// <li> VirtualArrayColumn
51// </prerequisite>
52
53// <synopsis>
54// MappedArrayEngine is a virtual column engine which maps an array
55// of one type to another type (without any scaling).
56//
57// An engine object should be used for one column only, because the stored
58// column name is part of the engine. If it would be used for more than
59// one column, they would all share the same stored column.
60// When the engine is bound to a column, it is checked if the name
61// of that column matches the given virtual column name.
62//
63// The engine can be used for a column containing any kind of array
64// (thus direct or indirect, fixed or variable shaped)) as long as the
65// virtual array can be stored in the stored array. Thus a fixed shaped
66// virtual can use a variable shaped stored, but not vice versa.
67// A fixed shape indirect virtual can use a stored with direct arrays.
68// </synopsis>
69
70// <motivation>
71// For precision it is sometimes needed to store the visibility data in a
72// MeasurementSet in double precision. To be able to use other applications
73// on such data, it is needed to map them to single precision.
74//
75// Because the engine can serve only one column, it was possible to
76// combine the engine and the column functionality in one class.
77// This has been achieved using multiple inheritance.
78// The advantage of this is that only one templated class is used,
79// so less template instantiations are needed.
80// </motivation>
81
82// <example>
83// <srcblock>
84// // Create the table description and 2 columns with indirect arrays in it.
85// // The Int column will be stored, while the double will be
86// // used as virtual.
87// TableDesc tableDesc ("", TableDesc::Scratch);
88// tableDesc.addColumn (ArrayColumnDesc<Int> ("storedArray"));
89// tableDesc.addColumn (ArrayColumnDesc<double> ("virtualArray"));
90//
91// // Create a new table using the table description.
92// SetupNewTable newtab (tableDesc, "tab.data", Table::New);
93//
94// // Create the array mapping engine to map from double to Int
95// // and bind it to the double column.
96// // Create the table.
97// MappedArrayEngine<double,Int> mappingEngine("virtualArray",
98// "storedArray", 10);
99// newtab.bindColumn ("virtualArray", mappingEngine);
100// Table table (newtab);
101//
102// // Store a 3-D array (with dim. 2,3,4) into each row of the column.
103// // The shape of each array in the column is implicitly set by the put
104// // function. This will also set the shape of the underlying Int array.
105// ArrayColumn data (table, "virtualArray");
106// Array<double> someArray(IPosition(4,2,3,4));
107// someArray = 0;
108// for (rownr_t i=0, i<10; i++) { // table will have 10 rows
109// table.addRow();
110// data.put (i, someArray)
111// }
112// </srcblock>
113// </example>
114
115// <templating arg=VirtualType>
116// <li> only suited for built-in numerics data types
117// </templating>
118// <templating arg=StoredType>
119// <li> only suited for built-in numerics data types
120// </templating>
121
122template<class VirtualType, class StoredType> class MappedArrayEngine : public BaseMappedArrayEngine<VirtualType, StoredType>
123{
124 //# Make members of parent class known.
125public:
126 using BaseMappedArrayEngine<VirtualType,StoredType>::virtualName;
127protected:
128 using BaseMappedArrayEngine<VirtualType,StoredType>::storedName;
129 using BaseMappedArrayEngine<VirtualType,StoredType>::table;
130 using BaseMappedArrayEngine<VirtualType,StoredType>::column;
131 using BaseMappedArrayEngine<VirtualType,StoredType>::setNames;
132
133public:
134 // Construct an engine to map all arrays in a column.
135 // StoredColumnName is the name of the column where the mapped
136 // data will be put and must have data type StoredType.
137 // The virtual column using this engine must have data type VirtualType.
138 MappedArrayEngine (const String& virtualColumnName,
139 const String& storedColumnName);
140
141 // Construct from a record specification as created by dataManagerSpec().
143
144 // Destructor is mandatory.
146
147 // Return the type name of the engine (i.e. its class name).
148 virtual String dataManagerType() const;
149
150 // Get the name given to the engine (is the virtual column name).
151 virtual String dataManagerName() const;
152
153 // Record a record containing data manager specifications.
154 virtual Record dataManagerSpec() const;
155
156 // Return the name of the class.
157 // This includes the names of the template arguments.
159
160 // Register the class name and the static makeObject "constructor".
161 // This will make the engine known to the table system.
162 // The automatically invoked registration function in DataManReg.cc
163 // contains MappedArrayEngine<double,Int>.
164 // Any other instantiation of this class must be registered "manually"
165 // (or added to DataManReg.cc).
166 static void registerClass();
167
168private:
169 // Copy constructor is only used by clone().
170 // (so it is made private).
172
173 // Assignment is not needed and therefore forbidden
174 // (so it is made private and not implemented).
177
178 // Clone the engine object.
180
181 // Copy the stored array to the virtual array.
183 const Array<StoredType>& stored);
184
185 // Copy the virtual array to the stored array.
186 virtual void mapOnPut (const Array<VirtualType>& array,
187 Array<StoredType>& stored);
188
189
190public:
191 // Define the "constructor" to construct this engine when a
192 // table is read back.
193 // This "constructor" has to be registered by the user of the engine.
194 // If the engine is commonly used, its registration can be added
195 // to the registerAllCtor function in DataManReg.cc.
196 // That function gets automatically invoked by the table system.
198 const Record& spec);
199};
200
201
202
203} //# NAMESPACE CASACORE - END
204
205#ifndef CASACORE_NO_AUTO_TEMPLATES
206#include <casacore/tables/DataMan/MappedArrayEngine.tcc>
207#endif //# CASACORE_NO_AUTO_TEMPLATES
208#endif
ArrayColumn< StoredType > & column()
Give access to the stored column.
void setNames(const String &virtualName, const String &storedName)
Set the virtual and stored column name.
const String & storedName() const
Get the stored column name.
const String & virtualName() const
Get the virtual column name.
Abstract base class for a data manager.
Table & table() const
Get the table this object is associated with.
virtual String dataManagerName() const
Get the name given to the engine (is the virtual column name).
MappedArrayEngine(const Record &spec)
Construct from a record specification as created by dataManagerSpec().
~MappedArrayEngine()
Destructor is mandatory.
virtual void mapOnPut(const Array< VirtualType > &array, Array< StoredType > &stored)
Copy the virtual array to the stored array.
static void registerClass()
Register the class name and the static makeObject "constructor".
DataManager * clone() const
Clone the engine object.
virtual String dataManagerType() const
Return the type name of the engine (i.e.
virtual Record dataManagerSpec() const
Record a record containing data manager specifications.
MappedArrayEngine(const MappedArrayEngine< VirtualType, StoredType > &)
Copy constructor is only used by clone().
static String className()
Return the name of the class.
MappedArrayEngine(const String &virtualColumnName, const String &storedColumnName)
Construct an engine to map all arrays in a column.
virtual void mapOnGet(Array< VirtualType > &array, const Array< StoredType > &stored)
Copy the stored array to the virtual array.
static DataManager * makeObject(const String &dataManagerType, const Record &spec)
Define the "constructor" to construct this engine when a table is read back.
String: the storage and methods of handling collections of characters.
Definition String.h:225
this file contains all the compiler specific defines
Definition mainpage.dox:28
TableExprNode array(const TableExprNode &values, const TableExprNodeSet &shape)
Create an array of the given shape and fill it with the values.
Definition ExprNode.h:1929