# Package uk.ac.starlink.table

package uk.ac.starlink.table
Defines an interface for access to astronomical tables.

Related Packages
Package
Description
uk.ac.starlink.table.formats
Table I/O handlers for various miscellaneous (mostly text-based) table serialization formats.
uk.ac.starlink.table.gui
Provides graphical classes used for rendering StarTable objects, and related utility functionality.
uk.ac.starlink.table.jdbc
Table classes related to JDBC (SQL database connectivity) handling.
uk.ac.starlink.table.storage
RowStore implementations.
Class
Description
AbstractStarTable
Abstract base class providing an implementation of the generic and straightforward parts of the `StarTable` interface.
AccessRowSequence
RowSequence implementation based on a RowAccess.
ArrayColumn
A column which provides data storage in java arrays.
BeanStarTable
StarTable which displays beans.
BlankColumn
Represents a column with metadata but no data.
ByteStore
Defines a place where bytes can be written to and then read from.
CalcStarTable<C>
StarTable implementation whose column values are derived from some single calculation on the column values of another table.
CalcStarTable.Col<C,T>
Defines a column for use with this table implementation.
ClassTableScheme
TableScheme implementation that allows to use any TableScheme implementation on the classpath.
ColumnData
A column which can supply and possibly store cells in array-like storage as well as supply column metadata.
ColumnInfo
Contains information about a table column.
ColumnPermutedStarTable
Wrapper table which provides a view of a base table in which the columns are permuted.
ColumnStarTable
A random-access StarTable that manages its data in columns.
ConcatStarTable
StarTable implementation which concatenates several tables together top-to-bottom.
ConstantColumn
Represents a column which has the same value in every row.
ConstantStarTable
Table implementation representing a table in which every row is the same as every other.
CountCheckRowSequence
RowSequence wrapper class that guarantees a given number of rows.
DefaultValueInfo
Default implementation of the `ValueInfo` interface.
DescribedValue
Contains a value (an `Object`) as well as a `ValueInfo` object which provides metadata about that value (name, class, shape, units and so on).
Documented
Mixin interface that provides extended user documentation for an object.
Domain<M extends DomainMapper>
Common value domain.
DomainMapper
Marker interface for objects that can map input values to a particular common value domain.
EditableColumn
A column which can be initialised from a given existing column, but whose cells can be written to.
EmptyRowSequence
Implementation of both RowSequence and RowAccess which has no rows.
EmptyStarTable
A wrapper table which has the same metadata as its base table, but no rows.
ExplodedStarTable
Wrapper table which takes any column whose value is N-element arrays and turns it into N scalar-valued columns.
HealpixTableInfo
Defines how to store metadata in a table so that STIL knows it contains a HEALPix map.
HealpixTableInfo.HpxCoordSys
Characterises the coordinate systems defined by the HEALpix-FITS serialization convention.
IteratorRowSequence
Implementation of `RowSequence` based on an Iterator which returns table rows in sequence.
IteratorRowSequence.PackagedIOException
Unchecked exception class to be used for smuggling `IOException`s out of the `next` method of an Iterator for use by `IteratorRowSequence`
JoinFixAction
Class defining the possible actions for doctoring column names when joining tables.
JoinStarTable
Joins a number of tables to produce a single combined table.
LoopStarTable
Single-column table whose column values are the values of a loop iterator variable.
LoopTableScheme
TableScheme that yields a table with a single column giving loop variable values.
MappingRowSplittable
RowSplittable which wraps another RowSplittable but presents different column contents as controlled by a supplied column data mapping function.
MetaCopyStarTable
Wrapper table which makes deep copies of the table metadata, including column metadata and table parameters.
MetadataStarTable
Utility StarTable implementation which contains only metadata, no data.
MultiStarTableWriter
Interface for table output handlers that can write multiple tables to the same stream.
MultiTableBuilder
Interface for objects which can construct an array of StarTables from a data resource.
ObjectArrayColumn
A column which provides data storage in a java array of objects.
OnceRowPipe
Streaming `RowPipe` implementation which provides a one-shot table.
PrimitiveArrayColumn
A column which provides data storage in a java array of primitives.
ProgressLineStarTable
A WrapperStarTable which behaves the same as its base, except that any RowSequence taken out on it will display an ASCII progress line on a terminal describing how far through the table it's got.
ProgressRowSplittable
RowSplittable wrapper that can manage progress reporting, as well as force termination of iteration.
ProgressRowSplittable.Target
Callback interface for objects that will be informed about iteration progress, and also given the opportunity to terminate iteration.
QueueTableSequence
TableSequence implementation for concurrent use.
RandomRowSplittable
RowSplittable based on a RowAccess.
RandomStarTable
Implements a StarTable based on row and cell accessor methods that are random access and thread-safe.
ReaderRowSequence
Partial implementation of `RowSequence` suitable for subclassing by classes which can read a row at a time and don't know when the row stream will come to an end.
RowAccess
Provides random access to table data.
RowCollector<A>
Convenience implementation of `SplitCollector` for use with table row processing.
RowData
Allows access to the values in a single row of a table.
RowListStarTable
Simple modifiable StarTable implementation.
RowPermutedStarTable
Wrapper table which provides a view of a base table in which the rows are permuted.
RowPipe
TableSink implementation whose returned table reads concurrently from rows written into it.
RowRunner
Manages potentially parallel processing of StarTable row data.
RowSequence
Provides sequential access to the data in a table.
RowSplittable
RowSequence subinterface that is also suitable for parallel processing.
RowStore
Describes an object which can be used to store table data.
RowSubsetStarTable
Wraps a StarTable to present only a subset of its rows.
SelectorStarTable
Sequential wrapper table which selects only certain rows of its base table.
SequentialRowSplittable
RowSplittable based on a sequential RowSequence.
ShapeIterator
Iterates over a shape array, as got from `ValueInfo.getShape()`.
StarTable
Defines basic table functionality.
StarTableFactory
Manufactures `StarTable` objects from generic inputs.
StarTableOutput
Outputs StarTable objects.
StarTableWriter
Defines an object which can output a `StarTable` in a particular format.
StoragePolicy
Defines storage methods for bulk data.
StreamStarTableWriter
Partial implementation of `StarTableWriter` which can be subclassed by writers which just write to output streams.
StreamTableSink
TableSink which turns its accepted data into a one-pass table and does something with it (calls `StreamTableSink.scanTable(StarTable)` on it).
TableBuilder
Interface for objects which can construct a `StarTable` from a data resource.
TableCopy
Class containing `main` method for copying tables.
TableFormatException
Exception thrown if a table handler fails to parse a table because it does not match the format it can decode.
TablePreparation
Hook for adding behaviour to StarTableFactory table loading.
Tables
Utility class for miscellaneous table-related functionality.
TableScheme
Defines a way to specify a StarTable given a textual specification.
TableSequence
Iterator over tables.
TableSink
Defines a set of callbacks to consume the information held in a StarTable.
TableSource
General purpose interface for objects which can supply a table.
TestTableScheme
TableScheme implementation for test data.
TimeDomain
Domain representing epochs in a common time scale.
TimeMapper
DomainMapper for mapping values to epochs in a common time scale.
UCD
Describes Uniform Column Descriptors.
UnrepeatableSequenceException
Exception thrown by `StarTable.getRowSequence()` calls after the first for tables which can only provide a single `RowSequence`.
URLValueInfo
ValueInfo for URL values.
ValueInfo
Describes a value, for instance one obtained from cells in a given table column, or from a table parameter.
ValueStore
Interface for storing a vector of values.
WrapperColumn
ColumnData which wraps another ColumnData.
WrapperRowAccess
RowAccess which wraps another RowAccess.
WrapperRowSequence
RowSequence which wraps another RowSequence.
WrapperStarTable
StarTable which wraps another StarTable.