Loading...
Searching...
No Matches
ExprNodeArray.h
Go to the documentation of this file.
//# ExprNodeArray.h: Classes representing an array in table select expression
//# Copyright (C) 1997,1999,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_EXPRNODEARRAY_H
#define TABLES_EXPRNODEARRAY_H
//# Includes
#include <casacore/tables/TaQL/ExprNodeRep.h>
#include <casacore/tables/TaQL/TaQLStyle.h>
#include <casacore/tables/Tables/Table.h>
#include <casacore/tables/Tables/ArrayColumn.h>
#include <casacore/casa/Arrays/Slicer.h>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
//# Forward Declarations
class TableExprNodeSet;
// <summary>
// Base class for arrays in table select expression
// </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
// <li> TableExprNodeBinary
// </prerequisite>
// <synopsis>
// This class is the base class to represent an array.
// The actual storing of the array column is done by its derivations.
// </synopsis>
class TableExprNodeArray : public TableExprNodeBinary
{
public:
// Create the object.
// <group>
TableExprNodeArray (NodeDataType, OperType);
TableExprNodeArray (const TableExprNodeRep& node, NodeDataType, OperType);
TableExprNodeArray (NodeDataType, OperType, const IPosition& shape);
// </group>
~TableExprNodeArray() override = default;
// Turn a constant array with one element into a scalar.
// It returns a zero pointer if not possible.
// The default implementation returns 0.
virtual TENShPtr makeConstantScalar();
// Validate the given index against the array's shape.
// Treat a negative as an index from the end (a la python) and replace it.
IPosition validateIndex (const IPosition& index,
const ArrayBase& arr) const;
// Get the shape of the array in the given row.
// This default implementation evaluates the value and returns its shape.
const IPosition& getShape (const TableExprId& id) override;
// The default implementation of getArrayDouble does
// getArrayInt and converts the result.
MArray<Double> getArrayDouble (const TableExprId& id) override;
// The default implementation of getArrayDComplex does
// getArrayDouble and converts the result.
MArray<DComplex> getArrayDComplex (const TableExprId& id) override;
// Does a value occur in the set?
// <group>
Bool contains (const TableExprId& id, Bool value) override;
Bool contains (const TableExprId& id, Int64 value) override;
Bool contains (const TableExprId& id, Double value) override;
Bool contains (const TableExprId& id, DComplex value) override;
Bool contains (const TableExprId& id, String value) override;
Bool contains (const TableExprId& id, MVTime value) override;
MArray<Bool> contains (const TableExprId& id,
const MArray<Bool>& value) override;
MArray<Bool> contains (const TableExprId& id,
const MArray<Int64>& value) override;
MArray<Bool> contains (const TableExprId& id,
const MArray<Double>& value) override;
MArray<Bool> contains (const TableExprId& id,
const MArray<DComplex>& value) override;
MArray<Bool> contains (const TableExprId& id,
const MArray<String>& value) override;
MArray<Bool> contains (const TableExprId& id,
const MArray<MVTime>& value) override;
// </group>
// Get a single element from the array in the given row.
// <group>
virtual Bool getElemBool (const TableExprId& id,
const Slicer& index);
virtual Int64 getElemInt (const TableExprId& id,
const Slicer& index);
virtual Double getElemDouble (const TableExprId& id,
const Slicer& index);
virtual DComplex getElemDComplex (const TableExprId& id,
const Slicer& index);
virtual String getElemString (const TableExprId& id,
const Slicer& index);
virtual MVTime getElemDate (const TableExprId& id,
const Slicer& index);
// </group>
// Get a slice of the array in the given row.
// <group>
virtual MArray<Bool> getSliceBool (const TableExprId& id,
const Slicer&);
virtual MArray<Int64> getSliceInt (const TableExprId& id,
const Slicer&);
virtual MArray<Double> getSliceDouble (const TableExprId& id,
const Slicer&);
virtual MArray<DComplex> getSliceDComplex (const TableExprId& id,
const Slicer&);
virtual MArray<String> getSliceString (const TableExprId& id,
const Slicer&);
virtual MArray<MVTime> getSliceDate (const TableExprId& id,
const Slicer&);
// </group>
// Get a single element for the entire column (used by sort).
// <group>
virtual Array<Bool> getElemColumnBool (const Vector<rownr_t>& rownrs,
const Slicer&);
virtual Array<uChar> getElemColumnuChar (const Vector<rownr_t>& rownrs,
const Slicer&);
virtual Array<Short> getElemColumnShort (const Vector<rownr_t>& rownrs,
const Slicer&);
virtual Array<uShort> getElemColumnuShort (const Vector<rownr_t>& rownrs,
const Slicer&);
virtual Array<Int> getElemColumnInt (const Vector<rownr_t>& rownrs,
const Slicer&);
virtual Array<uInt> getElemColumnuInt (const Vector<rownr_t>& rownrs,
const Slicer&);
virtual Array<Int64> getElemColumnInt64 (const Vector<rownr_t>& rownrs,
const Slicer&);
virtual Array<Float> getElemColumnFloat (const Vector<rownr_t>& rownrs,
const Slicer&);
virtual Array<Double> getElemColumnDouble (const Vector<rownr_t>& rownrs,
const Slicer&);
virtual Array<Complex> getElemColumnComplex (const Vector<rownr_t>& rownrs,
const Slicer&);
virtual Array<DComplex> getElemColumnDComplex (const Vector<rownr_t>& rownrs,
const Slicer&);
virtual Array<String> getElemColumnString (const Vector<rownr_t>& rownrs,
const Slicer&);
// </group>
// Make an array with the given shape and fill it with the value.
static MArray<Int64> makeArray (const IPosition& shape, Int64 value);
static MArray<Double> makeArray (const IPosition& shape, Double value);
static MArray<DComplex> makeArray (const IPosition& shape,
const DComplex& value);
protected:
IPosition varShape_p;
};
// <summary>
// Base class for Array column in table select expression
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNodeArray
// </prerequisite>
// <synopsis>
// This class is the base class to store an array column.
// The actual storing of the array column is done by its derivations.
// </synopsis>
class TableExprNodeArrayColumn : public TableExprNodeArray
{
public:
// Create the object for the given column and table.
TableExprNodeArrayColumn (const TableColumn& tablecol,
const TableExprInfo&);
~TableExprNodeArrayColumn() override = default;
// Get the table info for this column.
TableExprInfo getTableInfo() const override;
// Do not apply the selection.
void disableApplySelection() override;
// Re-create the column object for a selection of rows.
void applySelection (const Vector<rownr_t>& rownrs) override;
// Get the TableColumn object.
const TableColumn& getColumn() const;
// Get the shape of the array in the given row.
const IPosition& getShape (const TableExprId& id) override;
// Is the value in the given row defined?
Bool isDefined (const TableExprId& id) override;
// Get the data type of this column.
// It returns with a True status.
Bool getColumnDataType (DataType&) const override;
protected:
TableExprInfo tableInfo_p;
TableColumn tabCol_p;
Bool applySelection_p;
};
// <summary>
// Bool array column in table select expression
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNodeArrayColumn
// </prerequisite>
// <synopsis>
// These classes store an array column of type X.
// </synopsis>
class TableExprNodeArrayColumnBool : public TableExprNodeArrayColumn
{
public:
TableExprNodeArrayColumnBool (const TableColumn&,
const TableExprInfo&);
~TableExprNodeArrayColumnBool() override = default;
// Re-create the column object for a selection of rows.
void applySelection (const Vector<rownr_t>& rownrs) override;
Bool getElemBool (const TableExprId& id, const Slicer& index) override;
MArray<Bool> getArrayBool (const TableExprId& id) override;
MArray<Bool> getSliceBool (const TableExprId& id, const Slicer&) override;
Array<Bool> getElemColumnBool (const Vector<rownr_t>& rownrs,
const Slicer&) override;
protected:
ArrayColumn<Bool> col_p;
};
// <summary>
// uChar array column in table select expression
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNodeArrayColumn
// </prerequisite>
// <synopsis>
// These classes store an array column of type X.
// </synopsis>
class TableExprNodeArrayColumnuChar : public TableExprNodeArrayColumn
{
public:
TableExprNodeArrayColumnuChar (const TableColumn&,
const TableExprInfo&);
~TableExprNodeArrayColumnuChar() override = default;
// Re-create the column object for a selection of rows.
void applySelection (const Vector<rownr_t>& rownrs) override;
Int64 getElemInt (const TableExprId& id, const Slicer& index) override;
MArray<Int64> getArrayInt (const TableExprId& id) override;
MArray<Int64> getSliceInt (const TableExprId& id,
const Slicer&) override;
Array<uChar> getElemColumnuChar (const Vector<rownr_t>& rownrs,
const Slicer&) override;
protected:
ArrayColumn<uChar> col_p;
};
// <summary>
// Short array column in table select expression
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNodeArrayColumn
// </prerequisite>
// <synopsis>
// These classes store an array column of type X.
// </synopsis>
class TableExprNodeArrayColumnShort : public TableExprNodeArrayColumn
{
public:
TableExprNodeArrayColumnShort (const TableColumn&,
const TableExprInfo&);
~TableExprNodeArrayColumnShort() override = default;
// Re-create the column object for a selection of rows.
void applySelection (const Vector<rownr_t>& rownrs) override;
Int64 getElemInt (const TableExprId& id, const Slicer& index) override;
MArray<Int64> getArrayInt (const TableExprId& id) override;
MArray<Int64> getSliceInt (const TableExprId& id,
const Slicer&) override;
Array<Short> getElemColumnShort (const Vector<rownr_t>& rownrs,
const Slicer&) override;
protected:
ArrayColumn<Short> col_p;
};
// <summary>
// uShort array column in table select expression
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNodeArrayColumn
// </prerequisite>
// <synopsis>
// These classes store an array column of type X.
// </synopsis>
class TableExprNodeArrayColumnuShort : public TableExprNodeArrayColumn
{
public:
TableExprNodeArrayColumnuShort (const TableColumn&,
const TableExprInfo&);
~TableExprNodeArrayColumnuShort() override = default;
// Re-create the column object for a selection of rows.
void applySelection (const Vector<rownr_t>& rownrs) override;
Int64 getElemInt (const TableExprId& id, const Slicer& index) override;
MArray<Int64> getArrayInt (const TableExprId& id) override;
MArray<Int64> getSliceInt (const TableExprId& id,
const Slicer&) override;
Array<uShort> getElemColumnuShort (const Vector<rownr_t>& rownrs,
const Slicer&) override;
protected:
ArrayColumn<uShort> col_p;
};
// <summary>
// Int array column in table select expression
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNodeArrayColumn
// </prerequisite>
// <synopsis>
// These classes store an array column of type X.
// </synopsis>
class TableExprNodeArrayColumnInt : public TableExprNodeArrayColumn
{
public:
TableExprNodeArrayColumnInt (const TableColumn&,
const TableExprInfo&);
~TableExprNodeArrayColumnInt() override = default;
// Re-create the column object for a selection of rows.
void applySelection (const Vector<rownr_t>& rownrs) override;
Int64 getElemInt (const TableExprId& id, const Slicer& index) override;
MArray<Int64> getArrayInt (const TableExprId& id) override;
MArray<Int64> getSliceInt (const TableExprId& id,
const Slicer&) override;
Array<Int> getElemColumnInt (const Vector<rownr_t>& rownrs,
const Slicer&) override;
protected:
ArrayColumn<Int> col_p;
};
// <summary>
// uInt array column in table select expression
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNodeArrayColumn
// </prerequisite>
// <synopsis>
// These classes store an array column of type X.
// </synopsis>
class TableExprNodeArrayColumnuInt : public TableExprNodeArrayColumn
{
public:
TableExprNodeArrayColumnuInt (const TableColumn&,
const TableExprInfo&);
~TableExprNodeArrayColumnuInt() override = default;
// Re-create the column object for a selection of rows.
void applySelection (const Vector<rownr_t>& rownrs) override;
Int64 getElemInt (const TableExprId& id, const Slicer& index) override;
MArray<Int64> getArrayInt (const TableExprId& id) override;
MArray<Int64> getSliceInt (const TableExprId& id,
const Slicer&) override;
Array<uInt> getElemColumnuInt (const Vector<rownr_t>& rownrs,
const Slicer&) override;
protected:
ArrayColumn<uInt> col_p;
};
// <summary>
// Int64 array column in table select expression
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNodeArrayColumn
// </prerequisite>
// <synopsis>
// These classes store an array column of type X.
// </synopsis>
class TableExprNodeArrayColumnInt64 : public TableExprNodeArrayColumn
{
public:
TableExprNodeArrayColumnInt64 (const TableColumn&,
const TableExprInfo&);
~TableExprNodeArrayColumnInt64() override = default;
// Re-create the column object for a selection of rows.
void applySelection (const Vector<rownr_t>& rownrs) override;
Int64 getElemInt (const TableExprId& id, const Slicer& index) override;
MArray<Int64> getArrayInt (const TableExprId& id) override;
MArray<Int64> getSliceInt (const TableExprId& id,
const Slicer&) override;
Array<Int64> getElemColumnInt64 (const Vector<rownr_t>& rownrs,
const Slicer&) override;
protected:
ArrayColumn<Int64> col_p;
};
// <summary>
// Float array column in table select expression
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNodeArrayColumn
// </prerequisite>
// <synopsis>
// These classes store an array column of type X.
// </synopsis>
class TableExprNodeArrayColumnFloat : public TableExprNodeArrayColumn
{
public:
TableExprNodeArrayColumnFloat (const TableColumn&,
const TableExprInfo&);
~TableExprNodeArrayColumnFloat() override = default;
// Re-create the column object for a selection of rows.
void applySelection (const Vector<rownr_t>& rownrs) override;
Double getElemDouble (const TableExprId& id, const Slicer& index) override;
MArray<Double> getArrayDouble (const TableExprId& id) override;
MArray<Double> getSliceDouble (const TableExprId& id,
const Slicer&) override;
Array<Float> getElemColumnFloat (const Vector<rownr_t>& rownrs,
const Slicer&) override;
protected:
ArrayColumn<Float> col_p;
};
// <summary>
// Double array column in table select expression
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNodeArrayColumn
// </prerequisite>
// <synopsis>
// These classes store an array column of type X.
// </synopsis>
class TableExprNodeArrayColumnDouble : public TableExprNodeArrayColumn
{
public:
TableExprNodeArrayColumnDouble (const TableColumn&,
const TableExprInfo&);
~TableExprNodeArrayColumnDouble() override = default;
// Re-create the column object for a selection of rows.
void applySelection (const Vector<rownr_t>& rownrs) override;
Double getElemDouble (const TableExprId& id, const Slicer& index) override;
MArray<Double> getArrayDouble (const TableExprId& id) override;
MArray<Double> getSliceDouble (const TableExprId& id,
const Slicer&) override;
Array<Double> getElemColumnDouble (const Vector<rownr_t>& rownrs,
const Slicer&) override;
protected:
ArrayColumn<Double> col_p;
};
// <summary>
// Complex array column in table select expression
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNodeArrayColumn
// </prerequisite>
// <synopsis>
// These classes store an array column of type X.
// </synopsis>
class TableExprNodeArrayColumnComplex : public TableExprNodeArrayColumn
{
public:
TableExprNodeArrayColumnComplex (const TableColumn&,
const TableExprInfo&);
~TableExprNodeArrayColumnComplex() override = default;
// Re-create the column object for a selection of rows.
void applySelection (const Vector<rownr_t>& rownrs) override;
DComplex getElemDComplex (const TableExprId& id, const Slicer& index) override;
MArray<DComplex> getArrayDComplex (const TableExprId& id) override;
MArray<DComplex> getSliceDComplex (const TableExprId& id,
const Slicer&) override;
Array<Complex> getElemColumnComplex (const Vector<rownr_t>& rownrs,
const Slicer&) override;
protected:
ArrayColumn<Complex> col_p;
};
// <summary>
// DComplex array column in table select expression
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNodeArrayColumn
// </prerequisite>
// <synopsis>
// These classes store an array column of type X.
// </synopsis>
class TableExprNodeArrayColumnDComplex : public TableExprNodeArrayColumn
{
public:
TableExprNodeArrayColumnDComplex (const TableColumn&,
const TableExprInfo&);
~TableExprNodeArrayColumnDComplex() override = default;
// Re-create the column object for a selection of rows.
void applySelection (const Vector<rownr_t>& rownrs) override;
DComplex getElemDComplex (const TableExprId& id, const Slicer& index) override;
MArray<DComplex> getArrayDComplex (const TableExprId& id) override;
MArray<DComplex> getSliceDComplex (const TableExprId& id,
const Slicer&) override;
Array<DComplex> getElemColumnDComplex (const Vector<rownr_t>& rownrs,
const Slicer&) override;
protected:
ArrayColumn<DComplex> col_p;
};
// <summary>
// String array column in table select expression
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNodeArrayColumn
// </prerequisite>
// <synopsis>
// These classes store an array column of type X.
// </synopsis>
class TableExprNodeArrayColumnString : public TableExprNodeArrayColumn
{
public:
TableExprNodeArrayColumnString (const TableColumn&,
const TableExprInfo&);
~TableExprNodeArrayColumnString() override = default;
// Re-create the column object for a selection of rows.
void applySelection (const Vector<rownr_t>& rownrs) override;
String getElemString (const TableExprId& id, const Slicer& index) override;
MArray<String> getArrayString (const TableExprId& id) override;
MArray<String> getSliceString (const TableExprId& id,
const Slicer&) override;
Array<String> getElemColumnString (const Vector<rownr_t>& rownrs,
const Slicer&) override;
protected:
ArrayColumn<String> col_p;
};
// <summary>
// The index of an array element in a table select expression
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> TableExprNodeMulti
// </prerequisite>
// <etymology>
// TableExprNodeIndex is used to store an index.
// All the operands must be Int.
// </etymology>
// <synopsis>
// TableExprNodeIndex is a derivation of TableExprNodeMulti
// expression tree that represents an index.
// </synopsis>
// <motivation>
// All operands of TableExprNodeIndex must be Int,
// therefore it is a derivation of TableExprNodeMulti.
// </motivation>
// <todo asof="$DATE:$">
//# A List of bugs, limitations, extensions or planned refinements.
// <li> to be filled in
// </todo>
class TableExprNodeIndex : public TableExprNodeMulti
{
public:
// Constructor
explicit TableExprNodeIndex (const TableExprNodeSet& indices,
const TaQLStyle& = TaQLStyle(0));
// Destructor
~TableExprNodeIndex() override = default;
// Link all the operands and check datatype.
// Calculate the IPosition values for the const operands.
void fillIndex (const TableExprNodeSet& indices);
// Check if the index values match the dimensionality and shape
// of fixed-shaped array.
void checkIndexValues (const TENShPtr& arrayNode);
// Get the Slicer value for a constant index.
const Slicer& getConstantSlicer() const;
// Get the Slicer value for the slice.
const Slicer& getSlicer (const TableExprId& id);
// Does it index a single element?
Bool isSingle() const;
protected:
Int origin_p; //# origin 0 for C++/Python; 1 for Glish
Int endMinus_p; //# subtract from end (origin and endExcl)
Bool isCOrder_p; //# True for Python
IPosition start_p; //# precalculated start values
IPosition end_p; //# precalculated end values (<0 = till end)
IPosition incr_p; //# precalculated increment values
Slicer slicer_p; //# combined start, end, and incr
Block<Bool> varIndex_p; //# is the start for the axes variable?
Bool isSingle_p; //# Index a single value?
// Precalculate the constant indices and store them.
void convertConstIndex();
// Fill the slicer for this row.
void fillSlicer (const TableExprId& id);
// Get the shape of the node involved. Reverse axes if needed.
IPosition getNodeShape (const TENShPtr& arrayNode) const;
};
// <summary>
// Array column part in table select expression
// </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
// <li> TableExprNodeBinary
// </prerequisite>
// <synopsis>
// This class handles a part of an array.
// It uses a TableExprNodeArray to handle the array
// and a TableExprNodeIndex to store the index.
// </synopsis>
class TableExprNodeArrayPart : public TableExprNodeArray
{
public:
TableExprNodeArrayPart (const TENShPtr& arrayNode,
const TENShPtr& indexNode);
~TableExprNodeArrayPart() override = default;
// Show the node.
void show (ostream& os, uInt indent) const override;
Bool getBool (const TableExprId& id) override;
Int64 getInt (const TableExprId& id) override;
Double getDouble (const TableExprId& id) override;
DComplex getDComplex (const TableExprId& id) override;
String getString (const TableExprId& id) override;
MVTime getDate (const TableExprId& id) override;
MArray<Bool> getArrayBool (const TableExprId& id) override;
MArray<Int64> getArrayInt (const TableExprId& id) override;
MArray<Double> getArrayDouble (const TableExprId& id) override;
MArray<DComplex> getArrayDComplex (const TableExprId& id) override;
MArray<String> getArrayString (const TableExprId& id) override;
MArray<MVTime> getArrayDate (const TableExprId& id) override;
// Get the data type of this column (if possible).
// It returns with a False status when the index is not constant
// (that means that the index can vary with row number).
Bool getColumnDataType (DataType&) const override;
Array<Bool> getColumnBool (const Vector<rownr_t>& rownrs) override;
Array<uChar> getColumnuChar (const Vector<rownr_t>& rownrs) override;
Array<Short> getColumnShort (const Vector<rownr_t>& rownrs) override;
Array<uShort> getColumnuShort (const Vector<rownr_t>& rownrs) override;
Array<Int> getColumnInt (const Vector<rownr_t>& rownrs) override;
Array<uInt> getColumnuInt (const Vector<rownr_t>& rownrs) override;
Array<Int64> getColumnInt64 (const Vector<rownr_t>& rownrs) override;
Array<Float> getColumnFloat (const Vector<rownr_t>& rownrs) override;
Array<Double> getColumnDouble (const Vector<rownr_t>& rownrs) override;
Array<Complex> getColumnComplex (const Vector<rownr_t>& rownrs) override;
Array<DComplex> getColumnDComplex (const Vector<rownr_t>& rownrs) override;
Array<String> getColumnString (const Vector<rownr_t>& rownrs) override;
// Get the index node.
const TableExprNodeIndex* getIndexNode() const;
// Get the array column node.
// It returns 0 if the parent object is no array column.
const TableExprNodeArrayColumn* getColumnNode() const;
private:
TableExprNodeIndex* inxNode_p;
TableExprNodeArray* arrNode_p;
TableExprNodeArrayColumn* colNode_p; //# 0 if arrNode is no arraycolumn
};
inline Bool TableExprNodeIndex::isSingle() const
{
return isSingle_p;
}
inline const Slicer& TableExprNodeIndex::getConstantSlicer() const
{
return slicer_p;
}
inline const Slicer& TableExprNodeIndex::getSlicer (const TableExprId& id)
{
if (!isConstant()) {
fillSlicer (id);
}
return slicer_p;
}
inline const TableColumn& TableExprNodeArrayColumn::getColumn() const
{
return tabCol_p;
}
inline const TableExprNodeIndex* TableExprNodeArrayPart::getIndexNode() const
{
return inxNode_p;
}
inline const TableExprNodeArrayColumn*
TableExprNodeArrayPart::getColumnNode() const
{
return colNode_p;
}
} //# NAMESPACE CASACORE - END
#endif
casacore::ArrayBase
Non-templated base class for templated Array class.
Definition ArrayBase.h:71
casacore::ArrayColumn
Definition ArrayColumn.h:98
casacore::Array
Definition Array.h:155
casacore::Block
Definition Block.h:140
casacore::IPosition
Definition IPosition.h:117
casacore::MArray
Definition MArray.h:68
casacore::MVTime
Definition MVTime.h:268
casacore::Slicer
Definition Slicer.h:287
casacore::String
String: the storage and methods of handling collections of characters.
Definition String.h:223
casacore::TaQLStyle
Definition TaQLStyle.h:63
casacore::TableColumn
Definition TableColumn.h:97
casacore::TableExprId
Definition TableExprId.h:95
casacore::TableExprInfo
Class to connect a Table and its alias name.
Definition ExprNodeRep.h:125
casacore::TableExprNodeArrayColumnBool::applySelection
void applySelection(const Vector< rownr_t > &rownrs) override
Re-create the column object for a selection of rows.
casacore::TableExprNodeArrayColumnBool::~TableExprNodeArrayColumnBool
~TableExprNodeArrayColumnBool() override=default
casacore::TableExprNodeArrayColumnBool::col_p
ArrayColumn< Bool > col_p
Definition ExprNodeArray.h:283
casacore::TableExprNodeArrayColumnBool::getElemColumnBool
Array< Bool > getElemColumnBool(const Vector< rownr_t > &rownrs, const Slicer &) override
Get a single element for the entire column (used by sort).
casacore::TableExprNodeArrayColumnBool::getArrayBool
MArray< Bool > getArrayBool(const TableExprId &id) override
Get an array value for this node in the given row.
casacore::TableExprNodeArrayColumnBool::getSliceBool
MArray< Bool > getSliceBool(const TableExprId &id, const Slicer &) override
Get a slice of the array in the given row.
casacore::TableExprNodeArrayColumnBool::getElemBool
Bool getElemBool(const TableExprId &id, const Slicer &index) override
Get a single element from the array in the given row.
casacore::TableExprNodeArrayColumnBool::TableExprNodeArrayColumnBool
TableExprNodeArrayColumnBool(const TableColumn &, const TableExprInfo &)
casacore::TableExprNodeArrayColumnComplex::col_p
ArrayColumn< Complex > col_p
Definition ExprNodeArray.h:634
casacore::TableExprNodeArrayColumnComplex::getSliceDComplex
MArray< DComplex > getSliceDComplex(const TableExprId &id, const Slicer &) override
casacore::TableExprNodeArrayColumnComplex::applySelection
void applySelection(const Vector< rownr_t > &rownrs) override
Re-create the column object for a selection of rows.
casacore::TableExprNodeArrayColumnComplex::getElemDComplex
DComplex getElemDComplex(const TableExprId &id, const Slicer &index) override
casacore::TableExprNodeArrayColumnComplex::getElemColumnComplex
Array< Complex > getElemColumnComplex(const Vector< rownr_t > &rownrs, const Slicer &) override
casacore::TableExprNodeArrayColumnComplex::~TableExprNodeArrayColumnComplex
~TableExprNodeArrayColumnComplex() override=default
casacore::TableExprNodeArrayColumnComplex::getArrayDComplex
MArray< DComplex > getArrayDComplex(const TableExprId &id) override
The default implementation of getArrayDComplex does getArrayDouble and converts the result.
casacore::TableExprNodeArrayColumnComplex::TableExprNodeArrayColumnComplex
TableExprNodeArrayColumnComplex(const TableColumn &, const TableExprInfo &)
casacore::TableExprNodeArrayColumnDComplex::getElemColumnDComplex
Array< DComplex > getElemColumnDComplex(const Vector< rownr_t > &rownrs, const Slicer &) override
casacore::TableExprNodeArrayColumnDComplex::getArrayDComplex
MArray< DComplex > getArrayDComplex(const TableExprId &id) override
The default implementation of getArrayDComplex does getArrayDouble and converts the result.
casacore::TableExprNodeArrayColumnDComplex::getElemDComplex
DComplex getElemDComplex(const TableExprId &id, const Slicer &index) override
casacore::TableExprNodeArrayColumnDComplex::~TableExprNodeArrayColumnDComplex
~TableExprNodeArrayColumnDComplex() override=default
casacore::TableExprNodeArrayColumnDComplex::TableExprNodeArrayColumnDComplex
TableExprNodeArrayColumnDComplex(const TableColumn &, const TableExprInfo &)
casacore::TableExprNodeArrayColumnDComplex::col_p
ArrayColumn< DComplex > col_p
Definition ExprNodeArray.h:673
casacore::TableExprNodeArrayColumnDComplex::getSliceDComplex
MArray< DComplex > getSliceDComplex(const TableExprId &id, const Slicer &) override
casacore::TableExprNodeArrayColumnDComplex::applySelection
void applySelection(const Vector< rownr_t > &rownrs) override
Re-create the column object for a selection of rows.
casacore::TableExprNodeArrayColumnDouble::getArrayDouble
MArray< Double > getArrayDouble(const TableExprId &id) override
The default implementation of getArrayDouble does getArrayInt and converts the result.
casacore::TableExprNodeArrayColumnDouble::getElemDouble
Double getElemDouble(const TableExprId &id, const Slicer &index) override
casacore::TableExprNodeArrayColumnDouble::applySelection
void applySelection(const Vector< rownr_t > &rownrs) override
Re-create the column object for a selection of rows.
casacore::TableExprNodeArrayColumnDouble::col_p
ArrayColumn< Double > col_p
Definition ExprNodeArray.h:595
casacore::TableExprNodeArrayColumnDouble::getSliceDouble
MArray< Double > getSliceDouble(const TableExprId &id, const Slicer &) override
casacore::TableExprNodeArrayColumnDouble::getElemColumnDouble
Array< Double > getElemColumnDouble(const Vector< rownr_t > &rownrs, const Slicer &) override
casacore::TableExprNodeArrayColumnDouble::~TableExprNodeArrayColumnDouble
~TableExprNodeArrayColumnDouble() override=default
casacore::TableExprNodeArrayColumnDouble::TableExprNodeArrayColumnDouble
TableExprNodeArrayColumnDouble(const TableColumn &, const TableExprInfo &)
casacore::TableExprNodeArrayColumnFloat::getArrayDouble
MArray< Double > getArrayDouble(const TableExprId &id) override
The default implementation of getArrayDouble does getArrayInt and converts the result.
casacore::TableExprNodeArrayColumnFloat::applySelection
void applySelection(const Vector< rownr_t > &rownrs) override
Re-create the column object for a selection of rows.
casacore::TableExprNodeArrayColumnFloat::~TableExprNodeArrayColumnFloat
~TableExprNodeArrayColumnFloat() override=default
casacore::TableExprNodeArrayColumnFloat::getElemColumnFloat
Array< Float > getElemColumnFloat(const Vector< rownr_t > &rownrs, const Slicer &) override
casacore::TableExprNodeArrayColumnFloat::col_p
ArrayColumn< Float > col_p
Definition ExprNodeArray.h:556
casacore::TableExprNodeArrayColumnFloat::getSliceDouble
MArray< Double > getSliceDouble(const TableExprId &id, const Slicer &) override
casacore::TableExprNodeArrayColumnFloat::TableExprNodeArrayColumnFloat
TableExprNodeArrayColumnFloat(const TableColumn &, const TableExprInfo &)
casacore::TableExprNodeArrayColumnFloat::getElemDouble
Double getElemDouble(const TableExprId &id, const Slicer &index) override
casacore::TableExprNodeArrayColumnInt64::applySelection
void applySelection(const Vector< rownr_t > &rownrs) override
Re-create the column object for a selection of rows.
casacore::TableExprNodeArrayColumnInt64::getElemColumnInt64
Array< Int64 > getElemColumnInt64(const Vector< rownr_t > &rownrs, const Slicer &) override
casacore::TableExprNodeArrayColumnInt64::TableExprNodeArrayColumnInt64
TableExprNodeArrayColumnInt64(const TableColumn &, const TableExprInfo &)
casacore::TableExprNodeArrayColumnInt64::getArrayInt
MArray< Int64 > getArrayInt(const TableExprId &id) override
casacore::TableExprNodeArrayColumnInt64::col_p
ArrayColumn< Int64 > col_p
Definition ExprNodeArray.h:517
casacore::TableExprNodeArrayColumnInt64::~TableExprNodeArrayColumnInt64
~TableExprNodeArrayColumnInt64() override=default
casacore::TableExprNodeArrayColumnInt64::getElemInt
Int64 getElemInt(const TableExprId &id, const Slicer &index) override
casacore::TableExprNodeArrayColumnInt64::getSliceInt
MArray< Int64 > getSliceInt(const TableExprId &id, const Slicer &) override
casacore::TableExprNodeArrayColumnInt::applySelection
void applySelection(const Vector< rownr_t > &rownrs) override
Re-create the column object for a selection of rows.
casacore::TableExprNodeArrayColumnInt::TableExprNodeArrayColumnInt
TableExprNodeArrayColumnInt(const TableColumn &, const TableExprInfo &)
casacore::TableExprNodeArrayColumnInt::getArrayInt
MArray< Int64 > getArrayInt(const TableExprId &id) override
casacore::TableExprNodeArrayColumnInt::getElemInt
Int64 getElemInt(const TableExprId &id, const Slicer &index) override
casacore::TableExprNodeArrayColumnInt::col_p
ArrayColumn< Int > col_p
Definition ExprNodeArray.h:439
casacore::TableExprNodeArrayColumnInt::getElemColumnInt
Array< Int > getElemColumnInt(const Vector< rownr_t > &rownrs, const Slicer &) override
casacore::TableExprNodeArrayColumnInt::~TableExprNodeArrayColumnInt
~TableExprNodeArrayColumnInt() override=default
casacore::TableExprNodeArrayColumnInt::getSliceInt
MArray< Int64 > getSliceInt(const TableExprId &id, const Slicer &) override
casacore::TableExprNodeArrayColumnShort::getElemColumnShort
Array< Short > getElemColumnShort(const Vector< rownr_t > &rownrs, const Slicer &) override
casacore::TableExprNodeArrayColumnShort::getArrayInt
MArray< Int64 > getArrayInt(const TableExprId &id) override
casacore::TableExprNodeArrayColumnShort::col_p
ArrayColumn< Short > col_p
Definition ExprNodeArray.h:361
casacore::TableExprNodeArrayColumnShort::applySelection
void applySelection(const Vector< rownr_t > &rownrs) override
Re-create the column object for a selection of rows.
casacore::TableExprNodeArrayColumnShort::getElemInt
Int64 getElemInt(const TableExprId &id, const Slicer &index) override
casacore::TableExprNodeArrayColumnShort::getSliceInt
MArray< Int64 > getSliceInt(const TableExprId &id, const Slicer &) override
casacore::TableExprNodeArrayColumnShort::TableExprNodeArrayColumnShort
TableExprNodeArrayColumnShort(const TableColumn &, const TableExprInfo &)
casacore::TableExprNodeArrayColumnShort::~TableExprNodeArrayColumnShort
~TableExprNodeArrayColumnShort() override=default
casacore::TableExprNodeArrayColumnString::~TableExprNodeArrayColumnString
~TableExprNodeArrayColumnString() override=default
casacore::TableExprNodeArrayColumnString::TableExprNodeArrayColumnString
TableExprNodeArrayColumnString(const TableColumn &, const TableExprInfo &)
casacore::TableExprNodeArrayColumnString::getElemString
String getElemString(const TableExprId &id, const Slicer &index) override
casacore::TableExprNodeArrayColumnString::col_p
ArrayColumn< String > col_p
Definition ExprNodeArray.h:712
casacore::TableExprNodeArrayColumnString::getArrayString
MArray< String > getArrayString(const TableExprId &id) override
casacore::TableExprNodeArrayColumnString::applySelection
void applySelection(const Vector< rownr_t > &rownrs) override
Re-create the column object for a selection of rows.
casacore::TableExprNodeArrayColumnString::getSliceString
MArray< String > getSliceString(const TableExprId &id, const Slicer &) override
casacore::TableExprNodeArrayColumnString::getElemColumnString
Array< String > getElemColumnString(const Vector< rownr_t > &rownrs, const Slicer &) override
casacore::TableExprNodeArrayColumn
Base class for Array column in table select expression.
Definition ExprNodeArray.h:211
casacore::TableExprNodeArrayColumn::getShape
const IPosition & getShape(const TableExprId &id) override
Get the shape of the array in the given row.
casacore::TableExprNodeArrayColumn::applySelection
void applySelection(const Vector< rownr_t > &rownrs) override
Re-create the column object for a selection of rows.
casacore::TableExprNodeArrayColumn::tableInfo_p
TableExprInfo tableInfo_p
Definition ExprNodeArray.h:242
casacore::TableExprNodeArrayColumn::getColumn
const TableColumn & getColumn() const
Get the TableColumn object.
Definition ExprNodeArray.h:899
casacore::TableExprNodeArrayColumn::applySelection_p
Bool applySelection_p
Definition ExprNodeArray.h:244
casacore::TableExprNodeArrayColumn::isDefined
Bool isDefined(const TableExprId &id) override
Is the value in the given row defined?
casacore::TableExprNodeArrayColumn::~TableExprNodeArrayColumn
~TableExprNodeArrayColumn() override=default
casacore::TableExprNodeArrayColumn::disableApplySelection
void disableApplySelection() override
Do not apply the selection.
casacore::TableExprNodeArrayColumn::getColumnDataType
Bool getColumnDataType(DataType &) const override
Get the data type of this column.
casacore::TableExprNodeArrayColumn::tabCol_p
TableColumn tabCol_p
Definition ExprNodeArray.h:243
casacore::TableExprNodeArrayColumn::getTableInfo
TableExprInfo getTableInfo() const override
Get the table info for this column.
casacore::TableExprNodeArrayColumn::TableExprNodeArrayColumn
TableExprNodeArrayColumn(const TableColumn &tablecol, const TableExprInfo &)
Create the object for the given column and table.
casacore::TableExprNodeArrayColumnuChar::TableExprNodeArrayColumnuChar
TableExprNodeArrayColumnuChar(const TableColumn &, const TableExprInfo &)
casacore::TableExprNodeArrayColumnuChar::getElemColumnuChar
Array< uChar > getElemColumnuChar(const Vector< rownr_t > &rownrs, const Slicer &) override
casacore::TableExprNodeArrayColumnuChar::~TableExprNodeArrayColumnuChar
~TableExprNodeArrayColumnuChar() override=default
casacore::TableExprNodeArrayColumnuChar::getArrayInt
MArray< Int64 > getArrayInt(const TableExprId &id) override
casacore::TableExprNodeArrayColumnuChar::col_p
ArrayColumn< uChar > col_p
Definition ExprNodeArray.h:322
casacore::TableExprNodeArrayColumnuChar::getSliceInt
MArray< Int64 > getSliceInt(const TableExprId &id, const Slicer &) override
casacore::TableExprNodeArrayColumnuChar::getElemInt
Int64 getElemInt(const TableExprId &id, const Slicer &index) override
casacore::TableExprNodeArrayColumnuChar::applySelection
void applySelection(const Vector< rownr_t > &rownrs) override
Re-create the column object for a selection of rows.
casacore::TableExprNodeArrayColumnuInt::getElemInt
Int64 getElemInt(const TableExprId &id, const Slicer &index) override
casacore::TableExprNodeArrayColumnuInt::getSliceInt
MArray< Int64 > getSliceInt(const TableExprId &id, const Slicer &) override
casacore::TableExprNodeArrayColumnuInt::TableExprNodeArrayColumnuInt
TableExprNodeArrayColumnuInt(const TableColumn &, const TableExprInfo &)
casacore::TableExprNodeArrayColumnuInt::col_p
ArrayColumn< uInt > col_p
Definition ExprNodeArray.h:478
casacore::TableExprNodeArrayColumnuInt::getElemColumnuInt
Array< uInt > getElemColumnuInt(const Vector< rownr_t > &rownrs, const Slicer &) override
casacore::TableExprNodeArrayColumnuInt::getArrayInt
MArray< Int64 > getArrayInt(const TableExprId &id) override
casacore::TableExprNodeArrayColumnuInt::~TableExprNodeArrayColumnuInt
~TableExprNodeArrayColumnuInt() override=default
casacore::TableExprNodeArrayColumnuInt::applySelection
void applySelection(const Vector< rownr_t > &rownrs) override
Re-create the column object for a selection of rows.
casacore::TableExprNodeArrayColumnuShort::getElemColumnuShort
Array< uShort > getElemColumnuShort(const Vector< rownr_t > &rownrs, const Slicer &) override
casacore::TableExprNodeArrayColumnuShort::~TableExprNodeArrayColumnuShort
~TableExprNodeArrayColumnuShort() override=default
casacore::TableExprNodeArrayColumnuShort::TableExprNodeArrayColumnuShort
TableExprNodeArrayColumnuShort(const TableColumn &, const TableExprInfo &)
casacore::TableExprNodeArrayColumnuShort::getArrayInt
MArray< Int64 > getArrayInt(const TableExprId &id) override
casacore::TableExprNodeArrayColumnuShort::col_p
ArrayColumn< uShort > col_p
Definition ExprNodeArray.h:400
casacore::TableExprNodeArrayColumnuShort::applySelection
void applySelection(const Vector< rownr_t > &rownrs) override
Re-create the column object for a selection of rows.
casacore::TableExprNodeArrayColumnuShort::getElemInt
Int64 getElemInt(const TableExprId &id, const Slicer &index) override
casacore::TableExprNodeArrayColumnuShort::getSliceInt
MArray< Int64 > getSliceInt(const TableExprId &id, const Slicer &) override
casacore::TableExprNodeArrayPart::getColumnInt64
Array< Int64 > getColumnInt64(const Vector< rownr_t > &rownrs) override
casacore::TableExprNodeArrayPart::getArrayDate
MArray< MVTime > getArrayDate(const TableExprId &id) override
casacore::TableExprNodeArrayPart::~TableExprNodeArrayPart
~TableExprNodeArrayPart() override=default
casacore::TableExprNodeArrayPart::show
void show(ostream &os, uInt indent) const override
Show the node.
casacore::TableExprNodeArrayPart::getColumnDComplex
Array< DComplex > getColumnDComplex(const Vector< rownr_t > &rownrs) override
casacore::TableExprNodeArrayPart::getColumnuShort
Array< uShort > getColumnuShort(const Vector< rownr_t > &rownrs) override
casacore::TableExprNodeArrayPart::getColumnDataType
Bool getColumnDataType(DataType &) const override
Get the data type of this column (if possible).
casacore::TableExprNodeArrayPart::getColumnFloat
Array< Float > getColumnFloat(const Vector< rownr_t > &rownrs) override
casacore::TableExprNodeArrayPart::getColumnBool
Array< Bool > getColumnBool(const Vector< rownr_t > &rownrs) override
Get the value of the expression evaluated for the entire column.
casacore::TableExprNodeArrayPart::getBool
Bool getBool(const TableExprId &id) override
Get a scalar value for this node in the given row.
casacore::TableExprNodeArrayPart::colNode_p
TableExprNodeArrayColumn * colNode_p
Definition ExprNodeArray.h:877
casacore::TableExprNodeArrayPart::TableExprNodeArrayPart
TableExprNodeArrayPart(const TENShPtr &arrayNode, const TENShPtr &indexNode)
casacore::TableExprNodeArrayPart::getArrayDComplex
MArray< DComplex > getArrayDComplex(const TableExprId &id) override
The default implementation of getArrayDComplex does getArrayDouble and converts the result.
casacore::TableExprNodeArrayPart::getColumnNode
const TableExprNodeArrayColumn * getColumnNode() const
Get the array column node.
Definition ExprNodeArray.h:910
casacore::TableExprNodeArrayPart::getArrayDouble
MArray< Double > getArrayDouble(const TableExprId &id) override
The default implementation of getArrayDouble does getArrayInt and converts the result.
casacore::TableExprNodeArrayPart::getDComplex
DComplex getDComplex(const TableExprId &id) override
casacore::TableExprNodeArrayPart::getColumnString
Array< String > getColumnString(const Vector< rownr_t > &rownrs) override
casacore::TableExprNodeArrayPart::getArrayInt
MArray< Int64 > getArrayInt(const TableExprId &id) override
casacore::TableExprNodeArrayPart::getColumnuChar
Array< uChar > getColumnuChar(const Vector< rownr_t > &rownrs) override
casacore::TableExprNodeArrayPart::getDouble
Double getDouble(const TableExprId &id) override
casacore::TableExprNodeArrayPart::getIndexNode
const TableExprNodeIndex * getIndexNode() const
Get the index node.
Definition ExprNodeArray.h:904
casacore::TableExprNodeArrayPart::getDate
MVTime getDate(const TableExprId &id) override
casacore::TableExprNodeArrayPart::getColumnDouble
Array< Double > getColumnDouble(const Vector< rownr_t > &rownrs) override
casacore::TableExprNodeArrayPart::arrNode_p
TableExprNodeArray * arrNode_p
Definition ExprNodeArray.h:876
casacore::TableExprNodeArrayPart::getString
String getString(const TableExprId &id) override
casacore::TableExprNodeArrayPart::getColumnInt
Array< Int > getColumnInt(const Vector< rownr_t > &rownrs) override
casacore::TableExprNodeArrayPart::getColumnShort
Array< Short > getColumnShort(const Vector< rownr_t > &rownrs) override
casacore::TableExprNodeArrayPart::getArrayString
MArray< String > getArrayString(const TableExprId &id) override
casacore::TableExprNodeArrayPart::inxNode_p
TableExprNodeIndex * inxNode_p
Definition ExprNodeArray.h:875
casacore::TableExprNodeArrayPart::getColumnComplex
Array< Complex > getColumnComplex(const Vector< rownr_t > &rownrs) override
casacore::TableExprNodeArrayPart::getColumnuInt
Array< uInt > getColumnuInt(const Vector< rownr_t > &rownrs) override
casacore::TableExprNodeArrayPart::getArrayBool
MArray< Bool > getArrayBool(const TableExprId &id) override
Get an array value for this node in the given row.
casacore::TableExprNodeArrayPart::getInt
Int64 getInt(const TableExprId &id) override
casacore::TableExprNodeArray::~TableExprNodeArray
~TableExprNodeArray() override=default
casacore::TableExprNodeArray::getElemColumnDComplex
virtual Array< DComplex > getElemColumnDComplex(const Vector< rownr_t > &rownrs, const Slicer &)
casacore::TableExprNodeArray::getElemDouble
virtual Double getElemDouble(const TableExprId &id, const Slicer &index)
casacore::TableExprNodeArray::getElemColumnDouble
virtual Array< Double > getElemColumnDouble(const Vector< rownr_t > &rownrs, const Slicer &)
casacore::TableExprNodeArray::getArrayDComplex
MArray< DComplex > getArrayDComplex(const TableExprId &id) override
The default implementation of getArrayDComplex does getArrayDouble and converts the result.
casacore::TableExprNodeArray::getShape
const IPosition & getShape(const TableExprId &id) override
Get the shape of the array in the given row.
casacore::TableExprNodeArray::getElemColumnInt
virtual Array< Int > getElemColumnInt(const Vector< rownr_t > &rownrs, const Slicer &)
casacore::TableExprNodeArray::contains
Bool contains(const TableExprId &id, Double value) override
casacore::TableExprNodeArray::contains
MArray< Bool > contains(const TableExprId &id, const MArray< MVTime > &value) override
casacore::TableExprNodeArray::getSliceString
virtual MArray< String > getSliceString(const TableExprId &id, const Slicer &)
casacore::TableExprNodeArray::TableExprNodeArray
TableExprNodeArray(NodeDataType, OperType, const IPosition &shape)
casacore::TableExprNodeArray::contains
MArray< Bool > contains(const TableExprId &id, const MArray< Double > &value) override
casacore::TableExprNodeArray::getElemInt
virtual Int64 getElemInt(const TableExprId &id, const Slicer &index)
casacore::TableExprNodeArray::getElemString
virtual String getElemString(const TableExprId &id, const Slicer &index)
casacore::TableExprNodeArray::getElemColumnuInt
virtual Array< uInt > getElemColumnuInt(const Vector< rownr_t > &rownrs, const Slicer &)
casacore::TableExprNodeArray::getElemColumnInt64
virtual Array< Int64 > getElemColumnInt64(const Vector< rownr_t > &rownrs, const Slicer &)
casacore::TableExprNodeArray::getSliceBool
virtual MArray< Bool > getSliceBool(const TableExprId &id, const Slicer &)
Get a slice of the array in the given row.
casacore::TableExprNodeArray::contains
MArray< Bool > contains(const TableExprId &id, const MArray< String > &value) override
casacore::TableExprNodeArray::getSliceDComplex
virtual MArray< DComplex > getSliceDComplex(const TableExprId &id, const Slicer &)
casacore::TableExprNodeArray::getElemDComplex
virtual DComplex getElemDComplex(const TableExprId &id, const Slicer &index)
casacore::TableExprNodeArray::getElemColumnuChar
virtual Array< uChar > getElemColumnuChar(const Vector< rownr_t > &rownrs, const Slicer &)
casacore::TableExprNodeArray::getElemDate
virtual MVTime getElemDate(const TableExprId &id, const Slicer &index)
casacore::TableExprNodeArray::TableExprNodeArray
TableExprNodeArray(const TableExprNodeRep &node, NodeDataType, OperType)
casacore::TableExprNodeArray::getElemBool
virtual Bool getElemBool(const TableExprId &id, const Slicer &index)
Get a single element from the array in the given row.
casacore::TableExprNodeArray::makeArray
static MArray< Double > makeArray(const IPosition &shape, Double value)
casacore::TableExprNodeArray::contains
MArray< Bool > contains(const TableExprId &id, const MArray< Int64 > &value) override
casacore::TableExprNodeArray::contains
Bool contains(const TableExprId &id, String value) override
casacore::TableExprNodeArray::varShape_p
IPosition varShape_p
Definition ExprNodeArray.h:186
casacore::TableExprNodeArray::getSliceDate
virtual MArray< MVTime > getSliceDate(const TableExprId &id, const Slicer &)
casacore::TableExprNodeArray::getElemColumnuShort
virtual Array< uShort > getElemColumnuShort(const Vector< rownr_t > &rownrs, const Slicer &)
casacore::TableExprNodeArray::makeConstantScalar
virtual TENShPtr makeConstantScalar()
Turn a constant array with one element into a scalar.
casacore::TableExprNodeArray::contains
Bool contains(const TableExprId &id, MVTime value) override
casacore::TableExprNodeArray::getElemColumnString
virtual Array< String > getElemColumnString(const Vector< rownr_t > &rownrs, const Slicer &)
casacore::TableExprNodeArray::validateIndex
IPosition validateIndex(const IPosition &index, const ArrayBase &arr) const
Validate the given index against the array's shape.
casacore::TableExprNodeArray::contains
MArray< Bool > contains(const TableExprId &id, const MArray< DComplex > &value) override
casacore::TableExprNodeArray::makeArray
static MArray< DComplex > makeArray(const IPosition &shape, const DComplex &value)
casacore::TableExprNodeArray::TableExprNodeArray
TableExprNodeArray(NodeDataType, OperType)
Create the object.
casacore::TableExprNodeArray::contains
MArray< Bool > contains(const TableExprId &id, const MArray< Bool > &value) override
casacore::TableExprNodeArray::getArrayDouble
MArray< Double > getArrayDouble(const TableExprId &id) override
The default implementation of getArrayDouble does getArrayInt and converts the result.
casacore::TableExprNodeArray::makeArray
static MArray< Int64 > makeArray(const IPosition &shape, Int64 value)
Make an array with the given shape and fill it with the value.
casacore::TableExprNodeArray::getElemColumnBool
virtual Array< Bool > getElemColumnBool(const Vector< rownr_t > &rownrs, const Slicer &)
Get a single element for the entire column (used by sort).
casacore::TableExprNodeArray::getElemColumnShort
virtual Array< Short > getElemColumnShort(const Vector< rownr_t > &rownrs, const Slicer &)
casacore::TableExprNodeArray::contains
Bool contains(const TableExprId &id, DComplex value) override
casacore::TableExprNodeArray::getSliceDouble
virtual MArray< Double > getSliceDouble(const TableExprId &id, const Slicer &)
casacore::TableExprNodeArray::getSliceInt
virtual MArray< Int64 > getSliceInt(const TableExprId &id, const Slicer &)
casacore::TableExprNodeArray::getElemColumnComplex
virtual Array< Complex > getElemColumnComplex(const Vector< rownr_t > &rownrs, const Slicer &)
casacore::TableExprNodeArray::contains
Bool contains(const TableExprId &id, Bool value) override
Does a value occur in the set?
casacore::TableExprNodeArray::getElemColumnFloat
virtual Array< Float > getElemColumnFloat(const Vector< rownr_t > &rownrs, const Slicer &)
casacore::TableExprNodeArray::contains
Bool contains(const TableExprId &id, Int64 value) override
casacore::TableExprNodeBinary::TableExprNodeBinary
TableExprNodeBinary(NodeDataType, ValueType, OperType, ExprType)
Constructor.
casacore::TableExprNodeIndex
The index of an array element in a table select expression.
Definition ExprNodeArray.h:753
casacore::TableExprNodeIndex::isSingle
Bool isSingle() const
Does it index a single element?
Definition ExprNodeArray.h:883
casacore::TableExprNodeIndex::start_p
IPosition start_p
Definition ExprNodeArray.h:783
casacore::TableExprNodeIndex::fillIndex
void fillIndex(const TableExprNodeSet &indices)
Link all the operands and check datatype.
casacore::TableExprNodeIndex::isSingle_p
Bool isSingle_p
Definition ExprNodeArray.h:788
casacore::TableExprNodeIndex::getSlicer
const Slicer & getSlicer(const TableExprId &id)
Get the Slicer value for the slice.
Definition ExprNodeArray.h:891
casacore::TableExprNodeIndex::origin_p
Int origin_p
Definition ExprNodeArray.h:780
casacore::TableExprNodeIndex::TableExprNodeIndex
TableExprNodeIndex(const TableExprNodeSet &indices, const TaQLStyle &=TaQLStyle(0))
Constructor.
casacore::TableExprNodeIndex::getNodeShape
IPosition getNodeShape(const TENShPtr &arrayNode) const
Get the shape of the node involved.
casacore::TableExprNodeIndex::end_p
IPosition end_p
Definition ExprNodeArray.h:784
casacore::TableExprNodeIndex::isCOrder_p
Bool isCOrder_p
Definition ExprNodeArray.h:782
casacore::TableExprNodeIndex::endMinus_p
Int endMinus_p
Definition ExprNodeArray.h:781
casacore::TableExprNodeIndex::~TableExprNodeIndex
~TableExprNodeIndex() override=default
Destructor.
casacore::TableExprNodeIndex::varIndex_p
Block< Bool > varIndex_p
Definition ExprNodeArray.h:787
casacore::TableExprNodeIndex::slicer_p
Slicer slicer_p
Definition ExprNodeArray.h:786
casacore::TableExprNodeIndex::fillSlicer
void fillSlicer(const TableExprId &id)
Fill the slicer for this row.
casacore::TableExprNodeIndex::getConstantSlicer
const Slicer & getConstantSlicer() const
Get the Slicer value for a constant index.
Definition ExprNodeArray.h:887
casacore::TableExprNodeIndex::incr_p
IPosition incr_p
Definition ExprNodeArray.h:785
casacore::TableExprNodeIndex::convertConstIndex
void convertConstIndex()
Precalculate the constant indices and store them.
casacore::TableExprNodeIndex::checkIndexValues
void checkIndexValues(const TENShPtr &arrayNode)
Check if the index values match the dimensionality and shape of fixed-shaped array.
casacore::TableExprNodeMulti::TableExprNodeMulti
TableExprNodeMulti(NodeDataType, ValueType, OperType, const TableExprNodeRep &source)
Constructor.
casacore::TableExprNodeRep
Abstract base class for a node in a table column expression tree.
Definition ExprNodeRep.h:202
casacore::TableExprNodeRep::OperType
OperType
Define the operator types.
Definition ExprNodeRep.h:231
casacore::TableExprNodeRep::isConstant
Bool isConstant() const
Is the expression a constant?
Definition ExprNodeRep.h:744
casacore::TableExprNodeRep::NodeDataType
NodeDataType
Define the data types of a node.
Definition ExprNodeRep.h:205
casacore::TableExprNodeSet
Definition ExprNodeSet.h:87
casacore::Vector
Definition Vector.h:82
casacore
this file contains all the compiler specific defines
Definition mainpage.dox:28
casacore::uInt
unsigned int uInt
Definition aipstype.h:49
casacore::Int64
long long Int64
Define the extra non-standard types used by Casacore (like proposed uSize, Size).
Definition aipsxtype.h:36
casacore::shape
IPosition shape(const RecordFieldId &) const
Get the actual shape of this field.
casacore::TENShPtr
std::shared_ptr< TableExprNodeRep > TENShPtr
Definition ExprNodeRep.h:55
casacore::Int
int Int
Definition aipstype.h:48
casacore::Bool
bool Bool
Define the standard types used by Casacore.
Definition aipstype.h:40
casacore::value
NewDelAllocator< T > NewDelAllocator< T >::value
Definition Allocator.h:369
casacore::Double
double Double
Definition aipstype.h:53