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.
RowSequence wrapper class that guarantees a given number of rows.
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.
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.