Package uk.ac.starlink.table


package uk.ac.starlink.table
Defines an interface for access to astronomical tables.
  • Class
    Description
    Abstract base class providing an implementation of the generic and straightforward parts of the StarTable interface.
    RowSequence implementation based on a RowAccess.
    A column which provides data storage in java arrays.
    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.
    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.
    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.
    A random-access StarTable that manages its data in columns.
    StarTable implementation which concatenates several tables together top-to-bottom.
    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.
    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).
    Mixin interface that provides extended user documentation for an object.
    Domain<M extends DomainMapper>
    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.
    Wrapper table which takes any column whose value is N-element arrays and turns it into N scalar-valued columns.
    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.
    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
    Class defining the possible actions for doctoring column names when joining tables.
    Joins a number of tables to produce a single combined table.
    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.
    RowSplittable which wraps another RowSplittable but presents different column contents as controlled by a supplied column data mapping function.
    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.
    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.
    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 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.
    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.
    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.
    Sequential wrapper table which selects only certain rows of its base table.
    RowSplittable based on a sequential RowSequence.
    Iterates over a shape array, as got from ValueInfo.getShape().
    Defines basic table functionality.
    Manufactures StarTable objects from generic inputs.
    Outputs StarTable objects.
    Defines an object which can output a StarTable in a particular format.
    Defines storage methods for bulk data.
    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).
    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.
    Hook for adding behaviour to StarTableFactory table loading.
    Utility class for miscellaneous table-related functionality.
    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.
    TableScheme implementation for test data.
    Domain representing epochs in a common time scale.
    DomainMapper for mapping values to epochs in a common time scale.
    Describes Uniform Column Descriptors.
    Exception thrown by StarTable.getRowSequence() calls after the first for tables which can only provide a single RowSequence.
    ValueInfo for URL values.
    Describes a value, for instance one obtained from cells in a given table column, or from a table parameter.
    Interface for storing a vector of values.
    ColumnData which wraps another ColumnData.
    RowAccess which wraps another RowAccess.
    RowSequence which wraps another RowSequence.
    StarTable which wraps another StarTable.