Loading...
Searching...
No Matches
TableExprData.h
Go to the documentation of this file.
//# TableExprData.h: Abstract base class for data object in a TaQL expression
//# Copyright (C) 2000,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_TABLEEXPRDATA_H
#define TABLES_TABLEEXPRDATA_H
//# Includes
#include <casacore/casa/aips.h>
#include <casacore/casa/Utilities/DataType.h>
#include <casacore/casa/Arrays/ArrayFwd.h>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
//# Forward Declarations
class String;
class IPosition;
template<class T> class Block;
// <summary>
// Abstract base class for data object in a TaQL expression.
// </summary>
// <use visibility=export>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
// <li> <linkto class="TableExprNode">TableExprNode</linkto>.
// </prerequisite>
// <synopsis>
// The Table Query Language (TaQL) is implemented by means of the
// <src>TableExprNode</src> classes. It is primarily meant to do
// selection on tables. However, it is also possible to use it for
// selection on any other set of data resembling tabular data.
// <br>An example of such a data set is a set of
// <linkto class=Record>Record</linkto> objects. TaQL can be used
// to select some of those records based on the contents of one or more
// fields in the records. Note that this example is already directly
// supported by TaQL.
// <br>Another example is when a user has several equally long vectors
// with data. The vectors can be seen as fields and TaQL can be used
// to select entries from the vectors. This example requires that
// this class TableExprData is used.
// <p>
// The <linkto class=TableExprNodeRecordField>TableExprNodeRecordField</linkto>
// and <linkto class=TableExprId>TableExprId</linkto> classes form
// the means by which TaQL can deal with any set of data.
// <br>First the TaQL expression has to be setup. This is done by
// constructing a <src>TableExprNodeRecordField</src> object for each
// 'field' to be used in the expression. <src>TableExprNodeRecordField</src>
// uses a <linkto class=RecordInterface>RecordInterface</linkto> object
// to make the data type of a field in the data set known and to
// map a field name to a field index (the index is the sequence number
// of the field in the record description).
// <br>When evaluating the expression for each member in the data set,
// a <src>TableExprData></src> needs to be passed (which is automatically
// converted to <linkto class=TableExprId>TableExprId</linkto>).
// So a class needs to be written to access the data in the data set.
// It needs to be derived from the abstract base class <src>TableExprData</src>
// defined in this file. An example is given below.
// <p>
// It is also possible that the data set contains records and that
// the selection is based on fields in those records. In such a case
// the record passed to <src>TableExprNodeRecordField</src> should contain
// subrecords representing those records. The field index in the various
// functions as passed as a <src>Block<Int></src> to denote the fields
// in the subrecords (and possibly subsubrecords, etc..
// However, normally records won't be used and <src>fieldNrs[0]</src>
// gives the field index.
// </synopsis>
// <example>
// This example shows how a data set consisting of two vectors
// of scalars can be used.
// <srcblock>
// // Write a class derived from TableExprData to handle the vectors.
// class MyTestClass : public TableExprData
// {
// public:
// // Constructor checks if both vectors have equal length.
// MyTestClass (const Vector<Int>& fld1, const Vector<String>& fld2)
// : itsFld1(fld1), itsFld2(fld2), itsEntry(0)
// { AlwaysAssert (fld1.nelements() == fld2.nelements(), AipsError); }
// virtual ~MyTestClass()
// {}
// void next()
// { itsEntry++; }
// // Note that only the get functions for the possible types are needed.
// // Also note that all numeric types are handled by TaQL as Double.
// // The exception should never be thrown unless things are screwed up.
// virtual Double getDouble (const Block<Int>& fieldNrs) const
// { switch (fieldNrs[0]) {
// case 0:
// return itsFld1(itsEntry);
// default:
// throw AipsError();
// }
// }
// virtual String getString (const Block<Int>& fieldNrs) const
// { switch (fieldNrs[0]) {
// case 1:
// return itsFld2(itsEntry);
// default:
// throw AipsError();
// }
// }
// virtual DataType dataType (const Block<Int>& fieldNrs) const
// { switch (fieldNrs[0]) {
// case 0:
// return TpInt;
// case 1:
// return TpString;
// default:
// throw AipsError();
// }
// }
// // Make a Record to give to vectors a name.
// // The order in which the fields are defined determines the fieldnrs
// // passed to the get functions.
// static Record makeRecord()
// { RecordDesc desc;
// desc.addField ("fld1", TpInt);
// desc.addField ("fld2", TpString);
// return Record(desc);
// }
// private:
// Vector<Int> itsFld1;
// Vector<String> itsFld2;
// uInt itsEntry;
// };
//
// Vector<uInt> findMatches (const Vector<Int>& fld1,
// const Vector<String>& fld2)
// {
// // Make some expression.
// // First create a Record to make the names and types known.
// Record rec(MyTestClass::makeRecord());
// TableExprNode expr (makeRecordExpr(rec,"fld1") > 10 &&
// makeRecordExpr(rec,"fld2") != pattern("*xxx*"));
// // Now evaluate the expression for each entry in the vector.
// // Make a MyTestClass object to handle the vectors and put it in
// // a TableExprId object for the TaQL evaluator.
// // Note that TableExprId holds a pointer to the original MyTestClass
// // object, so the TaQL evaluator 'sees' the changes we make by
// // using the its next() function.
// MyTestClass subj(fld1, fld2);
// TableExprId eid(subj);
// // The matching entry numbers are stored in a vector.
// Vector<uInt> result(fld1.nelements());
// uInt nr=0;
// Bool valb;
// for (uInt i=0; i<fld1.nelements(); i++) {
// expr.get (eid, valb);
// if (valb) {
// result(nr++) = i;
// }
// subj.next(); // Next time the next entry must be used
// }
// result.resize (nr, True);
// return result;
// }
// </srcBlock>
// </example>
// <motivation>
// This class makes it possible that TaQL can be used in a very versatile way.
// </motivation>
//# <todo asof="1996/03/12">
//# </todo>
class TableExprData
{
public:
// Construct it from a row number.
TableExprData()
{;}
virtual ~TableExprData();
// Get the shape of the given field.
// Need only be implemented if there are arrays in the data.
// The default implementation returns an empty IPosition.
virtual IPosition shape (const Block<Int>& fieldNrs) const;
// Get the data type of the given field.
// Note that TpArray types have to be returned for arrays.
// If the field is unknown, TpOther should be returned.
// It is used for the isdefined function to check if the field
// is really defined.
virtual DataType dataType (const Block<Int>& fieldNrs) const = 0;
// Get a scalar in the given type.
// This might involve converting for Double and DComplex.
// Most default implementations throws an "not possible" exception.
// The default <src>getDouble</src> invokes <src>getInt</src>.
// The default <src>getDComplex</src> invokes <src>getDouble</src>.
// <group>
virtual Bool getBool (const Block<Int>& fieldNrs) const;
virtual Int64 getInt (const Block<Int>& fieldNrs) const;
virtual Double getDouble (const Block<Int>& fieldNrs) const;
virtual DComplex getDComplex (const Block<Int>& fieldNrs) const;
virtual String getString (const Block<Int>& fieldNrs) const;
// </group>
// Get an array in the given type.
// This might involve converting for Double and DComplex.
// Most default implementations throws an "not possible" exception.
// The default <src>getArrayDComplex</src> invokes
// <src>getArrayDouble</src>.
// <group>
virtual Array<Bool> getArrayBool (const Block<Int>& fieldNrs) const;
virtual Array<Int64> getArrayInt (const Block<Int>& fieldNrs) const;
virtual Array<Double> getArrayDouble (const Block<Int>& fieldNrs) const;
virtual Array<DComplex> getArrayDComplex (const Block<Int>& fieldNrs) const;
virtual Array<String> getArrayString (const Block<Int>& fieldNrs) const;
// </group>
};
} //# NAMESPACE CASACORE - END
#endif
casacore::Array
Definition Array.h:155
casacore::Block
simple 1-D array
Definition Block.h:198
casacore::IPosition
Definition IPosition.h:117
casacore::String
String: the storage and methods of handling collections of characters.
Definition String.h:223
casacore::TableExprData::getInt
virtual Int64 getInt(const Block< Int > &fieldNrs) const
casacore::TableExprData::~TableExprData
virtual ~TableExprData()
casacore::TableExprData::getArrayInt
virtual Array< Int64 > getArrayInt(const Block< Int > &fieldNrs) const
casacore::TableExprData::getBool
virtual Bool getBool(const Block< Int > &fieldNrs) const
Get a scalar in the given type.
casacore::TableExprData::getArrayBool
virtual Array< Bool > getArrayBool(const Block< Int > &fieldNrs) const
Get an array in the given type.
casacore::TableExprData::getArrayDouble
virtual Array< Double > getArrayDouble(const Block< Int > &fieldNrs) const
casacore::TableExprData::getDComplex
virtual DComplex getDComplex(const Block< Int > &fieldNrs) const
casacore::TableExprData::TableExprData
TableExprData()
Construct it from a row number.
Definition TableExprData.h:203
casacore::TableExprData::getArrayString
virtual Array< String > getArrayString(const Block< Int > &fieldNrs) const
casacore::TableExprData::getArrayDComplex
virtual Array< DComplex > getArrayDComplex(const Block< Int > &fieldNrs) const
casacore::TableExprData::shape
virtual IPosition shape(const Block< Int > &fieldNrs) const
Get the shape of the given field.
casacore::TableExprData::getDouble
virtual Double getDouble(const Block< Int > &fieldNrs) const
casacore::TableExprData::getString
virtual String getString(const Block< Int > &fieldNrs) const
casacore::TableExprData::dataType
virtual DataType dataType(const Block< Int > &fieldNrs) const =0
Get the data type of the given field.
casacore
this file contains all the compiler specific defines
Definition mainpage.dox:28
casacore::Int64
long long Int64
Define the extra non-standard types used by Casacore (like proposed uSize, Size).
Definition aipsxtype.h:36
casacore::Bool
bool Bool
Define the standard types used by Casacore.
Definition aipstype.h:40
casacore::Double
double Double
Definition aipstype.h:53