Loading...
Searching...
No Matches
ExprMathNodeArray.h
Go to the documentation of this file.
//# ExprMathArrayNode.h: Nodes representing mathematical array operators in table select expression tree
//# Copyright (C) 1997,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: casa-feedback@nrao.edu.
//# Postal address: AIPS++ Project Office
//# National Radio Astronomy Observatory
//# 520 Edgemont Road
//# Charlottesville, VA 22903-2475 USA
#ifndef TABLES_EXPRMATHNODEARRAY_H
#define TABLES_EXPRMATHNODEARRAY_H
//# Includes
#include <casacore/casa/aips.h>
#include <casacore/tables/TaQL/ExprNodeArray.h>
#include <casacore/casa/Arrays/Array.h>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
//# Forward Declarations
//# This file defines classes derived from TableExprNode representing
//# the data type and operator in a table expression.
//#
//# Data types Bool, Int64, Double, DComplex and String are used.
//# Char, uChar, Short, uShort, Int, and uInt are converted to Int64,
//# Float to Double, and Complex to DComplex.
//# Binary operators +, -, *, /, and % are recognized.
//# Also unary + and - are recognized.
// <summary>
// Array addition in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This abstract class represents an addition in a table expression tree.
// </synopsis>
class TableExprNodeArrayPlus : public TableExprNodeArray
{
public:
TableExprNodeArrayPlus (NodeDataType, const TableExprNodeRep&);
~TableExprNodeArrayPlus();
};
// <summary>
// Int Array addition in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This class represents an addition in a table select expression tree.
// Strings can also be added (ie. concatenated).
// Numeric data types will be promoted if possible, so for instance
// an addition of Int and Complex is possible.
// </synopsis>
class TableExprNodeArrayPlusInt : public TableExprNodeArrayPlus
{
public:
TableExprNodeArrayPlusInt (const TableExprNodeRep&);
~TableExprNodeArrayPlusInt();
MArray<Int64> getArrayInt (const TableExprId& id);
};
// <summary>
// Double Array addition in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This class represents an addition in a table select expression tree.
// Strings can also be added (ie. concatenated).
// Numeric data types will be promoted if possible, so for instance
// an addition of Int and Complex is possible.
// </synopsis>
class TableExprNodeArrayPlusDouble : public TableExprNodeArrayPlus
{
public:
TableExprNodeArrayPlusDouble (const TableExprNodeRep&);
~TableExprNodeArrayPlusDouble();
MArray<Double> getArrayDouble (const TableExprId& id);
};
// <summary>
// DComplex Array addition in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This class represents an addition in a table select expression tree.
// Strings can also be added (ie. concatenated).
// Numeric data types will be promoted if possible, so for instance
// an addition of Int and Complex is possible.
// </synopsis>
class TableExprNodeArrayPlusDComplex : public TableExprNodeArrayPlus
{
public:
TableExprNodeArrayPlusDComplex (const TableExprNodeRep&);
~TableExprNodeArrayPlusDComplex();
MArray<DComplex> getArrayDComplex (const TableExprId& id);
};
// <summary>
// String Array addition in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This class represents an addition in a table select expression tree.
// Strings can also be added (ie. concatenated).
// Numeric data types will be promoted if possible, so for instance
// an addition of Int and Complex is possible.
// </synopsis>
class TableExprNodeArrayPlusString : public TableExprNodeArrayPlus
{
public:
TableExprNodeArrayPlusString (const TableExprNodeRep&);
~TableExprNodeArrayPlusString();
MArray<String> getArrayString (const TableExprId& id);
};
// <summary>
// Date Array addition in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This class represents an addition in a table select expression tree.
// Strings can also be added (ie. concatenated).
// Numeric data types will be promoted if possible, so for instance
// an addition of Int and Complex is possible.
// </synopsis>
class TableExprNodeArrayPlusDate : public TableExprNodeArrayPlus
{
public:
TableExprNodeArrayPlusDate (const TableExprNodeRep&);
~TableExprNodeArrayPlusDate();
virtual void handleUnits();
MArray<Double> getArrayDouble (const TableExprId& id);
MArray<MVTime> getArrayDate (const TableExprId& id);
};
// <summary>
// Array addition in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This abstract class represents an addition in a table expression tree.
// </synopsis>
class TableExprNodeArrayMinus : public TableExprNodeArray
{
public:
TableExprNodeArrayMinus (NodeDataType, const TableExprNodeRep&);
~TableExprNodeArrayMinus();
};
// <summary>
// Int Array subtraction in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This class represents a subtraction in a table select expression tree.
// Numeric data types will be promoted if possible, so for instance
// a subtraction of Int and Complex is possible.
// </synopsis>
class TableExprNodeArrayMinusInt : public TableExprNodeArrayMinus
{
public:
TableExprNodeArrayMinusInt (const TableExprNodeRep&);
~TableExprNodeArrayMinusInt();
MArray<Int64> getArrayInt (const TableExprId& id);
};
// <summary>
// Double Array subtraction in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This class represents a subtraction in a table select expression tree.
// Numeric data types will be promoted if possible, so for instance
// a subtraction of Int and Complex is possible.
// </synopsis>
class TableExprNodeArrayMinusDouble : public TableExprNodeArrayMinus
{
public:
TableExprNodeArrayMinusDouble (const TableExprNodeRep&);
~TableExprNodeArrayMinusDouble();
MArray<Double> getArrayDouble (const TableExprId& id);
};
// <summary>
// DComplex Array subtraction in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This class represents a subtraction in a table select expression tree.
// Numeric data types will be promoted if possible, so for instance
// a subtraction of Int and Complex is possible.
// </synopsis>
class TableExprNodeArrayMinusDComplex : public TableExprNodeArrayMinus
{
public:
TableExprNodeArrayMinusDComplex (const TableExprNodeRep&);
~TableExprNodeArrayMinusDComplex();
MArray<DComplex> getArrayDComplex (const TableExprId& id);
};
// <summary>
// Date Array subtraction in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This class represents a subtraction in a table select expression tree.
// Numeric data types will be promoted if possible, so for instance
// a subtraction of Int and Complex is possible.
// </synopsis>
class TableExprNodeArrayMinusDate : public TableExprNodeArrayMinus
{
public:
TableExprNodeArrayMinusDate (const TableExprNodeRep&);
~TableExprNodeArrayMinusDate();
virtual void handleUnits();
MArray<Double> getArrayDouble (const TableExprId& id);
MArray<MVTime> getArrayDate (const TableExprId& id);
};
// <summary>
// Array addition in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This abstract class represents an addition in a table expression tree.
// </synopsis>
class TableExprNodeArrayTimes : public TableExprNodeArray
{
public:
TableExprNodeArrayTimes (NodeDataType, const TableExprNodeRep&);
~TableExprNodeArrayTimes();
virtual void handleUnits();
};
// <summary>
// Int Array multiplication in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This class represents a multiplication in a table select expression tree.
// Numeric data types will be promoted if possible, so for instance
// a multiplication of Int and Complex is possible.
// </synopsis>
class TableExprNodeArrayTimesInt : public TableExprNodeArrayTimes
{
public:
TableExprNodeArrayTimesInt (const TableExprNodeRep&);
~TableExprNodeArrayTimesInt();
MArray<Int64> getArrayInt (const TableExprId& id);
};
// <summary>
// Double Array multiplication in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This class represents a multiplication in a table select expression tree.
// Numeric data types will be promoted if possible, so for instance
// a multiplication of Int and Complex is possible.
// </synopsis>
class TableExprNodeArrayTimesDouble : public TableExprNodeArrayTimes
{
public:
TableExprNodeArrayTimesDouble (const TableExprNodeRep&);
~TableExprNodeArrayTimesDouble();
MArray<Double> getArrayDouble (const TableExprId& id);
};
// <summary>
// DComplex Array multiplication in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This class represents a multiplication in a table select expression tree.
// Numeric data types will be promoted if possible, so for instance
// a multiplication of Int and Complex is possible.
// </synopsis>
class TableExprNodeArrayTimesDComplex : public TableExprNodeArrayTimes
{
public:
TableExprNodeArrayTimesDComplex (const TableExprNodeRep&);
~TableExprNodeArrayTimesDComplex();
MArray<DComplex> getArrayDComplex (const TableExprId& id);
};
// <summary>
// Array addition in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This abstract class represents an addition in a table expression tree.
// </synopsis>
class TableExprNodeArrayDivide : public TableExprNodeArray
{
public:
TableExprNodeArrayDivide (NodeDataType, const TableExprNodeRep&);
~TableExprNodeArrayDivide();
virtual void handleUnits();
};
// <summary>
// Double Array division in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This class represents a division in a table select expression tree.
// Numeric data types will be promoted if possible, so for instance
// a division of Int and Complex is possible.
// </synopsis>
class TableExprNodeArrayDivideDouble : public TableExprNodeArrayDivide
{
public:
TableExprNodeArrayDivideDouble (const TableExprNodeRep&);
~TableExprNodeArrayDivideDouble();
MArray<Double> getArrayDouble (const TableExprId& id);
};
// <summary>
// DComplex Array division in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This class represents a division in a table select expression tree.
// Numeric data types will be promoted if possible, so for instance
// a division of Int and Complex is possible.
// </synopsis>
class TableExprNodeArrayDivideDComplex : public TableExprNodeArrayDivide
{
public:
TableExprNodeArrayDivideDComplex (const TableExprNodeRep&);
~TableExprNodeArrayDivideDComplex();
MArray<DComplex> getArrayDComplex (const TableExprId& id);
};
// <summary>
// Array addition in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This abstract class represents an addition in a table expression tree.
// </synopsis>
class TableExprNodeArrayModulo : public TableExprNodeArray
{
public:
TableExprNodeArrayModulo (NodeDataType, const TableExprNodeRep&);
~TableExprNodeArrayModulo();
virtual void handleUnits();
};
// <summary>
// Int Array modulo in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This class represents a modulo operation in a table select expression tree.
// It is only possible for datatype Int.
// </synopsis>
class TableExprNodeArrayModuloInt : public TableExprNodeArrayModulo
{
public:
TableExprNodeArrayModuloInt (const TableExprNodeRep&);
~TableExprNodeArrayModuloInt();
MArray<Int64> getArrayInt (const TableExprId& id);
};
// <summary>
// Double Array modulo in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This class represents a modulo operation in a table select expression tree.
// It is only possible for datatype Double.
// </synopsis>
class TableExprNodeArrayModuloDouble : public TableExprNodeArrayModulo
{
public:
TableExprNodeArrayModuloDouble (const TableExprNodeRep&);
~TableExprNodeArrayModuloDouble();
MArray<Double> getArrayDouble (const TableExprId& id);
};
// <summary>
// Int Array bitwise and in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This class represents a bitwise and operation in a table select expression
// tree. It is only possible for datatype Int.
// </synopsis>
class TableExprNodeArrayBitAndInt : public TableExprNodeArray
{
public:
TableExprNodeArrayBitAndInt (const TableExprNodeRep&);
~TableExprNodeArrayBitAndInt();
MArray<Int64> getArrayInt (const TableExprId& id);
};
// <summary>
// Int Array bitwise or in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This class represents a bitwise or operation in a table select expression
// tree. It is only possible for datatype Int.
// </synopsis>
class TableExprNodeArrayBitOrInt : public TableExprNodeArray
{
public:
TableExprNodeArrayBitOrInt (const TableExprNodeRep&);
~TableExprNodeArrayBitOrInt();
MArray<Int64> getArrayInt (const TableExprId& id);
};
// <summary>
// Int Array bitwise xor in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// <li> TableExprNodeRep
// </prerequisite>
// <synopsis>
// This class represents a bitwise xor operation in a table select expression
// tree. It is only possible for datatype Int.
// </synopsis>
class TableExprNodeArrayBitXorInt : public TableExprNodeArray
{
public:
TableExprNodeArrayBitXorInt (const TableExprNodeRep&);
~TableExprNodeArrayBitXorInt();
MArray<Int64> getArrayInt (const TableExprId& id);
};
// <summary>
// Unary minus in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// </prerequisite>
// <synopsis>
// This class represents a unary minus in a table select expression tree.
// This is defined for numeric data types only.
// </synopsis>
class TableExprNodeArrayMIN : public TableExprNodeArray
{
public:
TableExprNodeArrayMIN (const TableExprNodeRep&);
~TableExprNodeArrayMIN();
MArray<Int64> getArrayInt (const TableExprId& id);
MArray<Double> getArrayDouble (const TableExprId& id);
MArray<DComplex> getArrayDComplex (const TableExprId& id);
};
// <summary>
// Bitwise negate in table select expression tree
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNode
// </prerequisite>
// <synopsis>
// This class represents a bitwise negate in a table select expression tree.
// This is defined for Int data types only.
// </synopsis>
class TableExprNodeArrayBitNegate : public TableExprNodeArray
{
public:
TableExprNodeArrayBitNegate (const TableExprNodeRep&);
~TableExprNodeArrayBitNegate();
MArray<Int64> getArrayInt (const TableExprId& id);
};
} //# NAMESPACE CASACORE - END
#endif
casacore::MArray
Definition MArray.h:68
casacore::TableExprId
Definition TableExprId.h:95
casacore::TableExprNodeArrayBitAndInt::TableExprNodeArrayBitAndInt
TableExprNodeArrayBitAndInt(const TableExprNodeRep &)
casacore::TableExprNodeArrayBitAndInt::~TableExprNodeArrayBitAndInt
~TableExprNodeArrayBitAndInt()
casacore::TableExprNodeArrayBitAndInt::getArrayInt
MArray< Int64 > getArrayInt(const TableExprId &id)
casacore::TableExprNodeArrayBitNegate::~TableExprNodeArrayBitNegate
~TableExprNodeArrayBitNegate()
casacore::TableExprNodeArrayBitNegate::TableExprNodeArrayBitNegate
TableExprNodeArrayBitNegate(const TableExprNodeRep &)
casacore::TableExprNodeArrayBitNegate::getArrayInt
MArray< Int64 > getArrayInt(const TableExprId &id)
casacore::TableExprNodeArrayBitOrInt::getArrayInt
MArray< Int64 > getArrayInt(const TableExprId &id)
casacore::TableExprNodeArrayBitOrInt::TableExprNodeArrayBitOrInt
TableExprNodeArrayBitOrInt(const TableExprNodeRep &)
casacore::TableExprNodeArrayBitOrInt::~TableExprNodeArrayBitOrInt
~TableExprNodeArrayBitOrInt()
casacore::TableExprNodeArrayBitXorInt::TableExprNodeArrayBitXorInt
TableExprNodeArrayBitXorInt(const TableExprNodeRep &)
casacore::TableExprNodeArrayBitXorInt::~TableExprNodeArrayBitXorInt
~TableExprNodeArrayBitXorInt()
casacore::TableExprNodeArrayBitXorInt::getArrayInt
MArray< Int64 > getArrayInt(const TableExprId &id)
casacore::TableExprNodeArrayDivideDComplex::TableExprNodeArrayDivideDComplex
TableExprNodeArrayDivideDComplex(const TableExprNodeRep &)
casacore::TableExprNodeArrayDivideDComplex::~TableExprNodeArrayDivideDComplex
~TableExprNodeArrayDivideDComplex()
casacore::TableExprNodeArrayDivideDComplex::getArrayDComplex
MArray< DComplex > getArrayDComplex(const TableExprId &id)
The default implementation of getArrayDComplex does getArrayDouble and converts the result.
casacore::TableExprNodeArrayDivideDouble::TableExprNodeArrayDivideDouble
TableExprNodeArrayDivideDouble(const TableExprNodeRep &)
casacore::TableExprNodeArrayDivideDouble::getArrayDouble
MArray< Double > getArrayDouble(const TableExprId &id)
The default implementation of getArrayDouble does getArrayInt and converts the result.
casacore::TableExprNodeArrayDivideDouble::~TableExprNodeArrayDivideDouble
~TableExprNodeArrayDivideDouble()
casacore::TableExprNodeArrayDivide::TableExprNodeArrayDivide
TableExprNodeArrayDivide(NodeDataType, const TableExprNodeRep &)
casacore::TableExprNodeArrayDivide::handleUnits
virtual void handleUnits()
Handle the units of the children and possibly set the parent's unit.
casacore::TableExprNodeArrayDivide::~TableExprNodeArrayDivide
~TableExprNodeArrayDivide()
casacore::TableExprNodeArrayMIN::getArrayDComplex
MArray< DComplex > getArrayDComplex(const TableExprId &id)
The default implementation of getArrayDComplex does getArrayDouble and converts the result.
casacore::TableExprNodeArrayMIN::~TableExprNodeArrayMIN
~TableExprNodeArrayMIN()
casacore::TableExprNodeArrayMIN::TableExprNodeArrayMIN
TableExprNodeArrayMIN(const TableExprNodeRep &)
casacore::TableExprNodeArrayMIN::getArrayDouble
MArray< Double > getArrayDouble(const TableExprId &id)
The default implementation of getArrayDouble does getArrayInt and converts the result.
casacore::TableExprNodeArrayMIN::getArrayInt
MArray< Int64 > getArrayInt(const TableExprId &id)
casacore::TableExprNodeArrayMinusDComplex::TableExprNodeArrayMinusDComplex
TableExprNodeArrayMinusDComplex(const TableExprNodeRep &)
casacore::TableExprNodeArrayMinusDComplex::~TableExprNodeArrayMinusDComplex
~TableExprNodeArrayMinusDComplex()
casacore::TableExprNodeArrayMinusDComplex::getArrayDComplex
MArray< DComplex > getArrayDComplex(const TableExprId &id)
The default implementation of getArrayDComplex does getArrayDouble and converts the result.
casacore::TableExprNodeArrayMinusDate::handleUnits
virtual void handleUnits()
Handle the units of the children and possibly set the parent's unit.
casacore::TableExprNodeArrayMinusDate::getArrayDouble
MArray< Double > getArrayDouble(const TableExprId &id)
The default implementation of getArrayDouble does getArrayInt and converts the result.
casacore::TableExprNodeArrayMinusDate::getArrayDate
MArray< MVTime > getArrayDate(const TableExprId &id)
casacore::TableExprNodeArrayMinusDate::~TableExprNodeArrayMinusDate
~TableExprNodeArrayMinusDate()
casacore::TableExprNodeArrayMinusDate::TableExprNodeArrayMinusDate
TableExprNodeArrayMinusDate(const TableExprNodeRep &)
casacore::TableExprNodeArrayMinusDouble::getArrayDouble
MArray< Double > getArrayDouble(const TableExprId &id)
The default implementation of getArrayDouble does getArrayInt and converts the result.
casacore::TableExprNodeArrayMinusDouble::TableExprNodeArrayMinusDouble
TableExprNodeArrayMinusDouble(const TableExprNodeRep &)
casacore::TableExprNodeArrayMinusDouble::~TableExprNodeArrayMinusDouble
~TableExprNodeArrayMinusDouble()
casacore::TableExprNodeArrayMinusInt::TableExprNodeArrayMinusInt
TableExprNodeArrayMinusInt(const TableExprNodeRep &)
casacore::TableExprNodeArrayMinusInt::getArrayInt
MArray< Int64 > getArrayInt(const TableExprId &id)
casacore::TableExprNodeArrayMinusInt::~TableExprNodeArrayMinusInt
~TableExprNodeArrayMinusInt()
casacore::TableExprNodeArrayMinus::TableExprNodeArrayMinus
TableExprNodeArrayMinus(NodeDataType, const TableExprNodeRep &)
casacore::TableExprNodeArrayMinus::~TableExprNodeArrayMinus
~TableExprNodeArrayMinus()
casacore::TableExprNodeArrayModuloDouble::getArrayDouble
MArray< Double > getArrayDouble(const TableExprId &id)
The default implementation of getArrayDouble does getArrayInt and converts the result.
casacore::TableExprNodeArrayModuloDouble::TableExprNodeArrayModuloDouble
TableExprNodeArrayModuloDouble(const TableExprNodeRep &)
casacore::TableExprNodeArrayModuloDouble::~TableExprNodeArrayModuloDouble
~TableExprNodeArrayModuloDouble()
casacore::TableExprNodeArrayModuloInt::~TableExprNodeArrayModuloInt
~TableExprNodeArrayModuloInt()
casacore::TableExprNodeArrayModuloInt::getArrayInt
MArray< Int64 > getArrayInt(const TableExprId &id)
casacore::TableExprNodeArrayModuloInt::TableExprNodeArrayModuloInt
TableExprNodeArrayModuloInt(const TableExprNodeRep &)
casacore::TableExprNodeArrayModulo::TableExprNodeArrayModulo
TableExprNodeArrayModulo(NodeDataType, const TableExprNodeRep &)
casacore::TableExprNodeArrayModulo::~TableExprNodeArrayModulo
~TableExprNodeArrayModulo()
casacore::TableExprNodeArrayModulo::handleUnits
virtual void handleUnits()
Handle the units of the children and possibly set the parent's unit.
casacore::TableExprNodeArrayPlusDComplex::getArrayDComplex
MArray< DComplex > getArrayDComplex(const TableExprId &id)
The default implementation of getArrayDComplex does getArrayDouble and converts the result.
casacore::TableExprNodeArrayPlusDComplex::~TableExprNodeArrayPlusDComplex
~TableExprNodeArrayPlusDComplex()
casacore::TableExprNodeArrayPlusDComplex::TableExprNodeArrayPlusDComplex
TableExprNodeArrayPlusDComplex(const TableExprNodeRep &)
casacore::TableExprNodeArrayPlusDate::getArrayDate
MArray< MVTime > getArrayDate(const TableExprId &id)
casacore::TableExprNodeArrayPlusDate::TableExprNodeArrayPlusDate
TableExprNodeArrayPlusDate(const TableExprNodeRep &)
casacore::TableExprNodeArrayPlusDate::~TableExprNodeArrayPlusDate
~TableExprNodeArrayPlusDate()
casacore::TableExprNodeArrayPlusDate::getArrayDouble
MArray< Double > getArrayDouble(const TableExprId &id)
The default implementation of getArrayDouble does getArrayInt and converts the result.
casacore::TableExprNodeArrayPlusDate::handleUnits
virtual void handleUnits()
Handle the units of the children and possibly set the parent's unit.
casacore::TableExprNodeArrayPlusDouble::getArrayDouble
MArray< Double > getArrayDouble(const TableExprId &id)
The default implementation of getArrayDouble does getArrayInt and converts the result.
casacore::TableExprNodeArrayPlusDouble::TableExprNodeArrayPlusDouble
TableExprNodeArrayPlusDouble(const TableExprNodeRep &)
casacore::TableExprNodeArrayPlusDouble::~TableExprNodeArrayPlusDouble
~TableExprNodeArrayPlusDouble()
casacore::TableExprNodeArrayPlusInt::getArrayInt
MArray< Int64 > getArrayInt(const TableExprId &id)
casacore::TableExprNodeArrayPlusInt::TableExprNodeArrayPlusInt
TableExprNodeArrayPlusInt(const TableExprNodeRep &)
casacore::TableExprNodeArrayPlusInt::~TableExprNodeArrayPlusInt
~TableExprNodeArrayPlusInt()
casacore::TableExprNodeArrayPlusString::TableExprNodeArrayPlusString
TableExprNodeArrayPlusString(const TableExprNodeRep &)
casacore::TableExprNodeArrayPlusString::getArrayString
MArray< String > getArrayString(const TableExprId &id)
casacore::TableExprNodeArrayPlusString::~TableExprNodeArrayPlusString
~TableExprNodeArrayPlusString()
casacore::TableExprNodeArrayPlus::TableExprNodeArrayPlus
TableExprNodeArrayPlus(NodeDataType, const TableExprNodeRep &)
casacore::TableExprNodeArrayPlus::~TableExprNodeArrayPlus
~TableExprNodeArrayPlus()
casacore::TableExprNodeArrayTimesDComplex::TableExprNodeArrayTimesDComplex
TableExprNodeArrayTimesDComplex(const TableExprNodeRep &)
casacore::TableExprNodeArrayTimesDComplex::~TableExprNodeArrayTimesDComplex
~TableExprNodeArrayTimesDComplex()
casacore::TableExprNodeArrayTimesDComplex::getArrayDComplex
MArray< DComplex > getArrayDComplex(const TableExprId &id)
The default implementation of getArrayDComplex does getArrayDouble and converts the result.
casacore::TableExprNodeArrayTimesDouble::~TableExprNodeArrayTimesDouble
~TableExprNodeArrayTimesDouble()
casacore::TableExprNodeArrayTimesDouble::getArrayDouble
MArray< Double > getArrayDouble(const TableExprId &id)
The default implementation of getArrayDouble does getArrayInt and converts the result.
casacore::TableExprNodeArrayTimesDouble::TableExprNodeArrayTimesDouble
TableExprNodeArrayTimesDouble(const TableExprNodeRep &)
casacore::TableExprNodeArrayTimesInt::TableExprNodeArrayTimesInt
TableExprNodeArrayTimesInt(const TableExprNodeRep &)
casacore::TableExprNodeArrayTimesInt::getArrayInt
MArray< Int64 > getArrayInt(const TableExprId &id)
casacore::TableExprNodeArrayTimesInt::~TableExprNodeArrayTimesInt
~TableExprNodeArrayTimesInt()
casacore::TableExprNodeArrayTimes::TableExprNodeArrayTimes
TableExprNodeArrayTimes(NodeDataType, const TableExprNodeRep &)
casacore::TableExprNodeArrayTimes::handleUnits
virtual void handleUnits()
Handle the units of the children and possibly set the parent's unit.
casacore::TableExprNodeArrayTimes::~TableExprNodeArrayTimes
~TableExprNodeArrayTimes()
casacore::TableExprNodeArray::TableExprNodeArray
TableExprNodeArray(NodeDataType, OperType)
Create the object.
casacore::TableExprNodeRep
Abstract base class for a node in a table column expression tree.
Definition ExprNodeRep.h:202
casacore::TableExprNodeRep::NodeDataType
NodeDataType
Define the data types of a node.
Definition ExprNodeRep.h:205
casacore
this file contains all the compiler specific defines
Definition mainpage.dox:28