All Classes and Interfaces

Class
Description
Abstract base class providing an implementation of the generic and straightforward parts of the StarTable interface.
Partial implementation of TableLoadDialog interface.
A StarTableWriter which outputs text to a human-readable text file.
RowSequence implementation based on a RowAccess.
ByteStore which adopts a hybrid approach between use of memory and use of disk.
A column which provides data storage in java arrays.
ValueStore implementation which stores primitive values in a normal java array.
Simple ASCII-format table.
A table builder which reads tables in simple ASCII format.
A StarTableWriter which outputs text to a simple format machine-readable text file.
StarTable which displays beans.
Represents a column with metadata but no data.
Defines a place where bytes can be written to and then read from.
Interface for random access reading for data that has been written into a byte store.
RowStore based on a ByteStore.
Abstract StoragePolicy implementation based on a ByteStore.
StarTable implementation whose column values are derived from some single calculation on the column values of another table.
Defines a column for use with this table implementation.
TableScheme implementation that allows to use any TableScheme implementation on the classpath.
Serializes and deserializes objects to/from a data stream.
Can be used to make sense of the COINS data from the UK Government.
A column which can supply and possibly store cells in array-like storage as well as supply column metadata.
Contains information about a table column.
Wrapper table which provides a view of a base table in which the columns are permuted.
Accessor for stored values.
A random-access StarTable that manages its data in columns.
Defines an object which can store the data of a column, that is, an array of homogeneous objects.
StarTable implementation which retrieves its data from ColumnStore objects.
StarTable implementation which concatenates several tables together top-to-bottom.
Interface for objects which can supply a JDBC Connection to a single database.
Represents a column which has the same value in every row.
Table implementation representing a table in which every row is the same as every other.
Comma-Separated Value table.
A table builder which reads tables in Comma-Separated Values format.
A StarTableWriter which outputs to Comma-Separated Value format.
Default implementation of the ValueInfo interface.
Contains a value (an Object) as well as a ValueInfo object which provides metadata about that value (name, class, shape, units and so on).
ByteStore implementation which discards bytes.
Minimal implementation of RowStore which throws away the row data it is given.
Implementation of RowStore which stores data on disk.
Mixin interface that provides extended user documentation for an object.
Marker interface providing some behaviour that should be implemented by table I/O handlers to assist with auto-generating XML user documentation.
Partial StarTableWriter implementation for use by writers which just write to output streams, and which also implements DocumentedIOHandler.
Partial TableBuilder implementation that adds some behaviour useful when auto-generating XML user documentation for I/O handlers.
Common value domain.
Marker interface for objects that can map input values to a particular common value domain.
A column which can be initialised from a given existing column, but whose cells can be written to.
Implementation of both RowSequence and RowAccess which has no rows.
A wrapper table which has the same metadata as its base table, but no rows.
Defines how error messages are reported.
Wrapper table which takes any column whose value is N-element arrays and turns it into N scalar-valued columns.
ByteStore implementation which uses a temporary file.
Table load dialogue based on a FileChooser.
Load dialogue based on a FilestoreChooser.
Save dialogue which uses a FilestoreChooser.
Defines how to store metadata in a table so that STIL knows it contains a HEALPix map.
Characterises the coordinate systems defined by the HEALpix-FITS serialization convention.
A StarTableWriter that outputs text to HTML.
ColumnStore implementation which uses two streamed files to store a variable number of variable-length data items.
A table builder which reads tables in IPAC format.
A StarTableWriter which writes to the IPAC text format.
Implementation of RowSequence based on an Iterator which returns table rows in sequence.
Unchecked exception class to be used for smuggling IOExceptions out of the next method of an Iterator for use by IteratorRowSequence
Specifies authentication to make a JDBC connection.
Handles conversion of a StarTable into a new table in an RDBMS.
Describes a column as it will be written to a table in an RDBMS.
 
A StarTable implementation based on the results of an SQL query on a JDBC table.
TableScheme for intepreting JDBC-type URLs.
Utilties related to JDBC.
Class defining the possible actions for doctoring column names when joining tables.
Joins a number of tables to produce a single combined table.
A component which contains a list of (name, component) pairs.
A StarTableWriter that outputs text to a LaTeX document.
ByteStore wrapper class which will throw an IOException during writing if an attempt is made to store more than a fixed number of bytes.
Implementation of RowStore which stores data in memory.
Load dialogue which relies on the user typing the location into a text field.
Single-column table whose column values are the values of a loop iterator variable.
TableScheme that yields a table with a single column giving loop variable values.
Provides a TableModel view of a MapGroup object.
RowSplittable which wraps another RowSplittable but presents different column contents as controlled by a supplied column data mapping function.
ByteStore implementation which stores bytes in a buffer in memory.
Wrapper table which makes deep copies of the table metadata, including column metadata and table parameters.
Utility StarTable implementation which contains only metadata, no data.
Wrapper storage policy which derives its functionality from an existing ("base") policy, but additionally passes row storage events to a supplied TableSink.
Input handler for the so-called "Machine-Readable Table" format used by AAS journals.
JTable which can display multiple-line elements.
Interface for table output handlers that can write multiple tables to the same stream.
Interface for objects which can construct an array of StarTables from a data resource.
Partial implementation of ByteStoreAccess.
Provides better rendering of numeric table cells than the default JTable renderer.
A column which provides data storage in a java array of objects.
Streaming RowPipe implementation which provides a one-shot table.
A column which provides data storage in a java array of primitives.
A WrapperStarTable which behaves the same as its base, except that UI intervention is permitted on any RowSequence which is taken out on it.
TableSink implementation which messages a progress bar with row updates.
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.
RowSplittable wrapper that can manage progress reporting, as well as force termination of iteration.
Callback interface for objects that will be informed about iteration progress, and also given the opportunity to terminate iteration.
TableSequence implementation for concurrent use.
StarTable implementation based on a random-access ResultSet.
RowSplittable based on a RowAccess.
Implements a StarTable based on row and cell accessor methods that are random access and thread-safe.
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.
Provides random access to table data.
Convenience implementation of SplitCollector for use with table row processing.
Allows access to the values in a single row of a table.
Examines unknown rows (arrays of strings) to work out what they contain.
Interface for an object that can turn a string into a cell content object.
Helper class used to group quantities which describe what the data types found in the columns of a table are.
Simple modifiable StarTable implementation.
Wrapper table which provides a view of a base table in which the rows are permuted.
TableSink implementation whose returned table reads concurrently from rows written into it.
Manages potentially parallel processing of StarTable row data.
Provides sequential access to the data in a table.
RowSequence subinterface that is also suitable for parallel processing.
Describes an object which can be used to store table data.
Wraps a StarTable to present only a subset of its rows.
Handles asynchronous table saving.
Sequential wrapper table which selects only certain rows of its base table.
StarTable implementation based on a ResultSet.
RowSplittable based on a sequential RowSequence.
Iterates over a shape array, as got from ValueInfo.getShape().
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.
A component for eliciting a JDBC access type URL string from the user.
Summarises some aspects of the syntax of an SQL variant, and provides some utilities based on that.
Load dialogue for loading data from a database via JDBC.
A popup dialog for querying the user about the location of a new JDBC table to write.
Extends the JTable for use with StarTable objects.
Wraps the ResultSet class to provide the functions which are required to provide StarTable functionality.
Defines basic table functionality.
A TableColumn representing a column in a StarJTable.
Manufactures StarTable objects from generic inputs.
Adapts a StarTable into a TableModel.
Outputs StarTable objects.
Defines an object which can output a StarTable in a particular format.
Defines storage methods for bulk data.
ColumnStore implementation which uses a streamed file to store a variable number of fixed-length data items.
Abstract superclass for tables which reads a stream of characters to obtain the row data and metadata.
Partial implementation of StarTableWriter which can be subclassed by writers which just write to output streams.
TableSink which turns its accepted data into a one-pass table and does something with it (calls StreamTableSink.scanTable(uk.ac.starlink.table.StarTable) on it).
Implements JDBCAuthenticator using a GUI.
Uses the native system file dialogue to provide a TableLoader.
Table save dialogue based on the native system file dialogue.
Interface for objects which can construct a StarTable from a data resource.
Class containing main method for copying tables.
Exception thrown if a table handler fails to parse a table because it does not match the format it can decode.
Interface for a GUI-based consumer of tables which are being loaded.
Interface for an object which can handle the user interaction for selecting a table or tables to load.
Interface defining an object which can load tables.
Component which aggregates a TableLoadDialog and buttons (OK and Cancel) to control it.
TransferHandler which will load a table if it is dragged onto its owner component.
Thread which passes data from a TableLoader to a TableLoadClient.
Hook for adding behaviour to StarTableFactory table loading.
Provides a component suitable for use as a rowHeader component in the same JScrollPane as is being used to house a JTable.
Utility class for miscellaneous table-related functionality.
Dialog which permits a user to save one or more StarTables in a place and format of choice.
Interface for subdialogues which know how to save a table to some destination or other.
Defines a way to specify a StarTable given a textual specification.
Iterator over tables.
Defines a set of callbacks to consume the information held in a StarTable.
General purpose interface for objects which can supply a table.
Provides JDBC authentication using the terminal; assumes that someone is sitting at System.in.
TableScheme implementation for test data.
JDBC authenticator which keeps its data in the models of text GUI components (Document objects).
A StarTableWriter which outputs text to a human-readable text file.
Domain representing epochs in a common time scale.
DomainMapper for mapping values to epochs in a common time scale.
A table builder which reads tables in Tab-Separated Table format.
Output handler for Tab-Separated Table format.
Determines how JDBC types are mapped to java types.
TypeMapper implementation classes.
Describes Uniform Column Descriptors.
A component which enables selection of a UCD by the user.
Exception thrown by StarTable.getRowSequence() calls after the first for tables which can only provide a single RowSequence.
ValueInfo for URL values.
Defines how the data from a particular column of a JDBC table are turned into java objects.
Describes a value, for instance one obtained from cells in a given table column, or from a table parameter.
Can make a TableCellEditor suitable for a ValueInfo.
A TableCellRenderer which does its rendering according to a ValueInfo object which describes the values which it is expected to have to render.
Interface for storing a vector of values.
ListSelectionModel to use in conjunction with a ViewHugeTableModel for tracking row selection of very large tables.
Swing TableModel implementation which provides a view on a very large table model.
Implementation of the TableBuilder interface which gets StarTables from World Data Centre-type text files.
ColumnData which wraps another ColumnData.
RowAccess which wraps another RowAccess.
RowSequence which wraps another RowSequence.
StarTable which wraps another StarTable.
Defines how records are written to a database table.