# Class CalcStarTable<C>

java.lang.Object
uk.ac.starlink.table.AbstractStarTable
uk.ac.starlink.table.CalcStarTable<C>

Type Parameters:
  `C` - type of object that is calculated from each row of the input table, and supplies values to the corresponding row of this table

All Implemented Interfaces:
  `Closeable, AutoCloseable, StarTable`

public abstract class CalcStarTable<C> extends AbstractStarTable
StarTable implementation whose column values are derived from some single calculation on the column values of another table. The idea is that the cell values in a given row of an instance of this table are cheaply-obtained members of an object which is obtained by a potentially expensive calculation on the cell values of the corresponding row in the other table.

## Nested Class Summary

Nested Classes
Modifier and Type
Class
Description
`static interface`
`CalcStarTable.Col<C,T>`
Defines a column for use with this table implementation.

## Constructor Summary

Constructors
Constructor
Description
`CalcStarTable(StarTable base, CalcStarTable.Col<C,?>[] columns)`
Constructor.

## Method Summary

Modifier and Type
Method
Description
`abstract C`
`createCalculation(long irow)`
Creates the calculation object for the given row of the input table.
`abstract C`
`createCalculation(RowData baseRow)`
Creates the calculation object for the current row of the input table.
`StarTable`
`getBaseTable()`
Returns the input table on which this table is based.
`Object`
`getCell(long irow, int icol)`
The `AbstractStarTable` implementation of this method throws an `UnsupportedOperationException`, since unless otherwise provided there is no random access.
`int`
`getColumnCount()`
Returns the number of columns in this table.
`ColumnInfo`
`getColumnInfo(int icol)`
Returns the object describing the data in a given column.
`Object[]`
`getRow(long irow)`
The `AbstractStarTable` implementation of this method constructs a row by repeated invocation of `AbstractStarTable.getCell(long, int)`.
`RowAccess`
`getRowAccess()`
Returns an object which can provide random access to this table's data, if random access is implemented.
`long`
`getRowCount()`
Returns the number of rows in this table, if known.
`RowSequence`
`getRowSequence()`
Returns an object which can iterate over all the rows in the table sequentially.
`RowSplittable`
`getRowSplittable()`
Returns a default splittable which relies on table random access if available, or otherwise provides only sequential access (no splits).
`boolean`
`isRandom()`
The `AbstractStarTable` implementation of this method returns `false`.

### Methods inherited from class AbstractStarTable

`checkedLongToInt, close, getColumnAuxDataInfos, getName, getParameters, getURL, setName, setParameters, setURL`

### Methods inherited from class Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Methods inherited from interface StarTable

`getParameterByName, setParameter`

## Constructor Details

### CalcStarTable

public CalcStarTable(StarTable base, CalcStarTable.Col<C,?>[] columns)
Constructor.

Parameters:
  `base` - input table
  `columns` - array defining the columns of this table

## Method Details

### createCalculation

public abstract C createCalculation(RowData baseRow) throws IOException
Creates the calculation object for the current row of the input table.

Parameters:
  `baseRow` - row from base table
Returns:
  calculation object corresponding to `baseRow`
Throws:
  `IOException`

### createCalculation

public abstract C createCalculation(long irow) throws IOException
Creates the calculation object for the given row of the input table. Only works for random-access tables.

Parameters:
  `irow` - row index for which calculation is required
Returns:
  calculation object for input table row `irow`
Throws:
  `IOException`

### getBaseTable

public StarTable getBaseTable()
Returns the input table on which this table is based.

Returns:
  base table

### getColumnInfo

public ColumnInfo getColumnInfo(int icol)
Description copied from interface: `StarTable`
Returns the object describing the data in a given column.

Specified by:
  `getColumnInfo` in interface `StarTable`
Specified by:
  `getColumnInfo` in class `AbstractStarTable`
Parameters:
  `icol` - the column for which header information is required
Returns:
  a ValueInfo object for column `icol`

### getColumnCount

public int getColumnCount()
Description copied from interface: `StarTable`
Returns the number of columns in this table.

Specified by:
  `getColumnCount` in interface `StarTable`
Specified by:
  `getColumnCount` in class `AbstractStarTable`
Returns:
  the number of columns

### getRowCount

public long getRowCount()
Description copied from interface: `StarTable`
Returns the number of rows in this table, if known. If the number of rows cannot be (easily) determined, a value of -1 will be returned.

Specified by:
  `getRowCount` in interface `StarTable`
Specified by:
  `getRowCount` in class `AbstractStarTable`
Returns:
  the number of rows, or -1

### isRandom

public boolean isRandom()
Description copied from class: `AbstractStarTable`
The `AbstractStarTable` implementation of this method returns `false`.

Specified by:
  `isRandom` in interface `StarTable`
Overrides:
  `isRandom` in class `AbstractStarTable`
Returns:
  `true` if table random access methods are available

### getRowSequence

public RowSequence getRowSequence() throws IOException
Description copied from interface: `StarTable`
Returns an object which can iterate over all the rows in the table sequentially. Each such returned object is safe for use within a single thread, but not in general from multiple threads concurrently.

Specified by:
  `getRowSequence` in interface `StarTable`
Specified by:
  `getRowSequence` in class `AbstractStarTable`
Returns:
  new RowSequence
Throws:
  `IOException` - if there is an error providing access

### getRowSplittable

public RowSplittable getRowSplittable() throws IOException
Description copied from class: `AbstractStarTable`
Returns a default splittable which relies on table random access if available, or otherwise provides only sequential access (no splits).

It is often possible to provide a better implementation than this.

Specified by:
  `getRowSplittable` in interface `StarTable`
Overrides:
  `getRowSplittable` in class `AbstractStarTable`
Returns:
  `Tables.getDefaultRowSplittable(this)`
Throws:
  `IOException`
See Also:
  - `RowRunner`

### getRowAccess

public RowAccess getRowAccess() throws IOException
Description copied from interface: `StarTable`
Returns an object which can provide random access to this table's data, if random access is implemented. Each such returned object is safe for use within a single thread, but not in general from multiple threads concurrently.

Specified by:
  `getRowAccess` in interface `StarTable`
Overrides:
  `getRowAccess` in class `AbstractStarTable`
Returns:
  new RowAccess
Throws:
  `IOException` - if there is an error setting up access

### getRow

public Object[] getRow(long irow) throws IOException
Description copied from class: `AbstractStarTable`
The `AbstractStarTable` implementation of this method constructs a row by repeated invocation of `AbstractStarTable.getCell(long, int)`.

Specified by:
  `getRow` in interface `StarTable`
Overrides:
  `getRow` in class `AbstractStarTable`
Parameters:
  `irow` - the index of the row to retrieve
Returns:
  an array of the objects in each cell in row `irow`
Throws:
  `IOException` - if there is an error reading the data

### getCell

public Object getCell(long irow, int icol) throws IOException
Description copied from class: `AbstractStarTable`
The `AbstractStarTable` implementation of this method throws an `UnsupportedOperationException`, since unless otherwise provided there is no random access.

Specified by:
  `getCell` in interface `StarTable`
Overrides:
  `getCell` in class `AbstractStarTable`
Parameters:
  `irow` - the index of the cell's row
  `icol` - the index of the cell's column
Returns:
  the contents of this cell
Throws:
  `IOException` - if there is an error reading the data