# All Classes and Interfaces

Class
Description
AbstractStarTable
Abstract base class providing an implementation of the generic and straightforward parts of the `StarTable` interface.
AbstractTableLoadDialog
Partial implementation of TableLoadDialog interface.
AbstractTextTableWriter
A `StarTableWriter` which outputs text to a human-readable text file.
AccessRowSequence
RowSequence implementation based on a RowAccess.
AdaptiveByteStore
ByteStore which adopts a hybrid approach between use of memory and use of disk.
ArrayColumn
A column which provides data storage in java arrays.
ArrayPrimitiveStore
ValueStore implementation which stores primitive values in a normal java array.
AsciiStarTable
Simple ASCII-format table.
AsciiTableBuilder
A table builder which reads tables in simple ASCII format.
AsciiTableWriter
A StarTableWriter which outputs text to a simple format machine-readable text file.
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.
ByteStoreAccess
Interface for random access reading for data that has been written into a byte store.
ByteStoreRowStore
RowStore based on a ByteStore.
ByteStoreStoragePolicy
Abstract StoragePolicy implementation based on a ByteStore.
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.
Codec
Serializes and deserializes objects to/from a data stream.
CoinsTableBuilder
Can be used to make sense of the COINS data from the UK Government.
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.
ColumnReader
Accessor for stored values.
ColumnStarTable
A random-access StarTable that manages its data in columns.
ColumnStore
Defines an object which can store the data of a column, that is, an array of homogeneous objects.
ColumnStoreStarTable
StarTable implementation which retrieves its data from `ColumnStore` objects.
ConcatStarTable
StarTable implementation which concatenates several tables together top-to-bottom.
Connector
Interface for objects which can supply a JDBC Connection to a single database.
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.
CsvStarTable
Comma-Separated Value table.
CsvTableBuilder
A table builder which reads tables in Comma-Separated Values format.
CsvTableWriter
A StarTableWriter which outputs to Comma-Separated Value format.
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).
DiscardByteStore
ByteStore implementation which discards bytes.
DiscardRowStore
Minimal implementation of `RowStore` which throws away the row data it is given.
DiskRowStore
Implementation of RowStore which stores data on disk.
Documented
Mixin interface that provides extended user documentation for an object.
DocumentedIOHandler
Marker interface providing some behaviour that should be implemented by table I/O handlers to assist with auto-generating XML user documentation.
DocumentedStreamStarTableWriter
Partial StarTableWriter implementation for use by writers which just write to output streams, and which also implements DocumentedIOHandler.
DocumentedTableBuilder
Partial TableBuilder implementation that adds some behaviour useful when auto-generating XML user documentation for I/O handlers.
Domain<M>
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.
ErrorMode
Defines how error messages are reported.
ExplodedStarTable
Wrapper table which takes any column whose value is N-element arrays and turns it into N scalar-valued columns.
FileByteStore
ByteStore implementation which uses a temporary file.
FileChooserTableLoadDialog
Table load dialogue based on a FileChooser.
FilestoreTableLoadDialog
Load dialogue based on a FilestoreChooser.
FilestoreTableSaveDialog
Save dialogue which uses a `FilestoreChooser`.
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.
HTMLTableWriter
A StarTableWriter that outputs text to HTML.
IndexedStreamColumnStore
ColumnStore implementation which uses two streamed files to store a variable number of variable-length data items.
IpacTableBuilder
A table builder which reads tables in IPAC format.
IpacTableWriter
A StarTableWriter which writes to the IPAC text format.
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`
JDBCAuthenticator
Specifies authentication to make a JDBC connection.
JDBCFormatter
Handles conversion of a StarTable into a new table in an RDBMS.
JDBCFormatter.SqlColumn
Describes a column as it will be written to a table in an RDBMS.
JDBCHandler
JDBCStarTable
A StarTable implementation based on the results of an SQL query on a JDBC table.
JDBCTableScheme
TableScheme for intepreting JDBC-type URLs.
JDBCUtils
Utilties related to JDBC.
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.
LabelledComponentStack
A component which contains a list of (name, component) pairs.
LatexTableWriter
A StarTableWriter that outputs text to a LaTeX document.
LimitByteStore
ByteStore wrapper class which will throw an IOException during writing if an attempt is made to store more than a fixed number of bytes.
ListRowStore
Implementation of RowStore which stores data in memory.
LocationTableLoadDialog
Load dialogue which relies on the user typing the location into a text field.
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.
MapGroupTableModel<K,V>
Provides a `TableModel` view of a `MapGroup` object.
MappingRowSplittable
RowSplittable which wraps another RowSplittable but presents different column contents as controlled by a supplied column data mapping function.
MemoryByteStore
ByteStore implementation which stores bytes in a buffer in memory.
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.
MonitorStoragePolicy
Wrapper storage policy which derives its functionality from an existing ("base") policy, but additionally passes row storage events to a supplied TableSink.
MrtTableBuilder
Input handler for the so-called "Machine-Readable Table" format used by AAS journals.
MultilineJTable
JTable which can display multiple-line elements.
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.
NioByteStoreAccess
Partial implementation of ByteStoreAccess.
NumericCellRenderer
Provides better rendering of numeric table cells than the default JTable renderer.
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.
ProgressBarStarTable
A WrapperStarTable which behaves the same as its base, except that UI intervention is permitted on any RowSequence which is taken out on it.
ProgressBarTableSink
TableSink implementation which messages a progress bar with row updates.
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.
RandomResultSetStarTable
StarTable implementation based on a random-access `ResultSet`.
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.
RowEvaluator
Examines unknown rows (arrays of strings) to work out what they contain.
RowEvaluator.Decoder<T>
Interface for an object that can turn a string into a cell content object.
RowEvaluator.Metadata
Helper class used to group quantities which describe what the data types found in the columns of a table are.
RowEvaluatorTableBuilder
Partial TableBuilder implementation for TableBuilders based on a RowEvaluator.
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.
SaveWorker
Handles asynchronous table saving.
SelectorStarTable
Sequential wrapper table which selects only certain rows of its base table.
SequentialResultSetStarTable
StarTable implementation based on a `ResultSet`.
SequentialRowSplittable
RowSplittable based on a sequential RowSequence.
ShapeIterator
Iterates over a shape array, as got from `ValueInfo.getShape()`.
SidewaysRowStore
RowStore implementation which stores data cell data in a column-oriented fashion, so that members of the same column, rather than of the same row, are stored contiguously on disk.
SQLPanel
A component for eliciting a JDBC access type URL string from the user.
SqlSyntax
Summarises some aspects of the syntax of an SQL variant, and provides some utilities based on that.
SQLTableLoadDialog
Load dialogue for loading data from a database via JDBC.
SQLWriteDialog
A popup dialog for querying the user about the location of a new JDBC table to write.
StarJTable
Extends the `JTable` for use with `StarTable` objects.
StarResultSet
Wraps the `ResultSet` class to provide the functions which are required to provide `StarTable` functionality.
StarTable
Defines basic table functionality.
StarTableColumn
A `TableColumn` representing a column in a `StarJTable`.
StarTableFactory
Manufactures `StarTable` objects from generic inputs.
StarTableModel
Adapts a `StarTable` into a `TableModel`.
StarTableOutput
Outputs StarTable objects.
StarTableWriter
Defines an object which can output a `StarTable` in a particular format.
StoragePolicy
Defines storage methods for bulk data.
StreamColumnStore
ColumnStore implementation which uses a streamed file to store a variable number of fixed-length data items.
StreamStarTable
Abstract superclass for tables which reads a stream of characters to obtain the row data and metadata.
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).
SwingAuthenticator
Implements JDBCAuthenticator using a GUI.
SystemBrowser
Uses the native system file dialogue to provide a TableLoader.
SystemTableSaveDialog
Table save dialogue based on the native system file dialogue.
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.
TableLoadClient
Interface for a GUI-based consumer of tables which are being loaded.
TableLoadDialog
Interface for an object which can handle the user interaction for selecting a table or tables to load.
TableLoader
Interface defining an object which can load tables.
TableLoadPanel
Component which aggregates a TableLoadDialog and buttons (OK and Cancel) to control it.
TableLoadTransferHandler
TransferHandler which will load a table if it is dragged onto its owner component.
TableLoadWorker
Thread which passes data from a TableLoader to a TableLoadClient.
TablePreparation
Hook for adding behaviour to StarTableFactory table loading.
TableRowHeader
Provides a component suitable for use as a rowHeader component in the same `JScrollPane` as is being used to house a `JTable`.
Tables
Utility class for miscellaneous table-related functionality.
TableSaveChooser
Dialog which permits a user to save one or more `StarTable`s in a place and format of choice.
TableSaveDialog
Interface for subdialogues which know how to save a table to some destination or other.
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.
TerminalAuthenticator
Provides JDBC authentication using the terminal; assumes that someone is sitting at `System.in`.
TestTableScheme
TableScheme implementation for test data.
TextModelsAuthenticator
JDBC authenticator which keeps its data in the models of text GUI components (`Document` objects).
TextTableWriter
A `StarTableWriter` which outputs text to a human-readable text file.
TimeDomain
Domain representing epochs in a common time scale.
TimeMapper
DomainMapper for mapping values to epochs in a common time scale.
TstTableBuilder
A table builder which reads tables in Tab-Separated Table format.
TstTableWriter
Output handler for Tab-Separated Table format.
TypeMapper
Determines how JDBC types are mapped to java types.
TypeMappers
TypeMapper implementation classes.
UCD
Describes Uniform Column Descriptors.
UCDSelector
A component which enables selection of a UCD by the user.
UnrepeatableSequenceException
Exception thrown by `StarTable.getRowSequence()` calls after the first for tables which can only provide a single `RowSequence`.
URLValueInfo
ValueInfo for URL values.
ValueHandler
Defines how the data from a particular column of a JDBC table are turned into java objects.
ValueInfo
Describes a value, for instance one obtained from cells in a given table column, or from a table parameter.
ValueInfoCellEditor
Can make a TableCellEditor suitable for a ValueInfo.
ValueInfoCellRenderer
A `TableCellRenderer` which does its rendering according to a `ValueInfo` object which describes the values which it is expected to have to render.
ValueStore
Interface for storing a vector of values.
VerTableBuilder
Table builder for reading tables in the loosely-defined "ver" format.
ViewHugeSelectionModel
ListSelectionModel to use in conjunction with a ViewHugeTableModel for tracking row selection of very large tables.
ViewHugeTableModel
Swing TableModel implementation which provides a view on a very large table model.
WDCTableBuilder
Implementation of the `TableBuilder` interface which gets `StarTable`s from World Data Centre-type text files.
WrapperColumn
ColumnData which wraps another ColumnData.
WrapperRowAccess
RowAccess which wraps another RowAccess.
WrapperRowSequence
RowSequence which wraps another RowSequence.
WrapperStarTable
StarTable which wraps another StarTable.
WriteMode
Defines how records are written to a database table.