Columndescribes properties such as name (key) and type of elements related to that
Column(e.g. the according elements of the
Columninstances, for example describing the elements of a CSV file (visually speaking the of the CSV file's header line), is represented by the
Headerpreserves an order for a list of
Headerprovides the semantics for related
Columninstances is explicitly required (similar to a DB table or a spread sheet, in contrast to a CSV file) then
Columninstances are grouped by a
Rowholds multiple data elements loosely coupled to a
Header. As a
Rowjust contains a list of data elements with no keys (names) directly associated to the elements, a
Headerwith the according list of key (name) and type definitions is required to give a
In terms of a CSV file, a
Row represents a
single line of comma separated values. The
Header stands for the header line (top line) of
the CSV file. The semantics for the content of a
Row is provided by the according
Row instances are contained in a
Rows instance which in turn requires a single
Header to give all the therein contained
Row instances their semantics (in terms of key
(name) and type information).
In contrast to a
Row does not relate a key (name) to its values.
To do this, a
Header is required. Similar to a
Column instances (provided by a
Header instance) to give the fields additional
A bunch of
Rowinstances is represented by a
Rowsinstance. As of efficiency reasons, a
Rowsinstance can be iterated through, returning a single
Rowwithin each iteration. This approach is making it possible to query a DB in the background and just hold the
Rowinstances being served next in the
Rowsinstance (in memory).
The way how
Rows instances manage their related
Row instances is implementation specific, a
plain java implementation might use some kind of collection for storing the
Row instances (this can get memory intensive and
not applicable when working with big data). A DB implementation might
Row instances in blocks one by one,
one after the other, by querying the DB accordingly (in terms of "next"
Fielddata structures with support for
Fieldinstances can be managed with the functionality provided by a
A value can be retrieved from a
providing an according
Column definition, which
verifies the value type. Also values can be converted to and from the
appropriate interchange and string formats by the according
In contrast to a
Record relates the key (name) to its values.
Similar to a
Record makes use of
Column instances (for example as provided by a
Header or a
instance) to give the fields additional semantics.
Recordinstances is represented by a
Recordsinstance. As of efficiency reasons, a
Recordsinstance can be iterated through, returning a single
Recordwithin each iteration. This approach is making it possible to query a DB in the background and just hold the
Recordinstances being served next in the
Recordsinstance (in memory).
The way how
Records instances manage their
Record instances is implementation
specific, a plain java implementation might use some kind of collection for
Record instances (this can get
memory intensive and not applicable when working with big data). A DB
implementation might retrieve the
instances in blocks one by one, one after the other, by querying the DB
accordingly (in terms of "next" result sets).
Interface Summary Interface Description Column<T> ColumnAccessor<T>Provides an accessor for a
ColumnAccessor.ColumnMutator<T>Provides a mutator for a
ColumnFactory<T> ColumnRow<T,C extends Column<? extends T>> Columns<T> Field<T>A
Fieldstores an attribute consisting of a key (name) and a value.
Fieldsstores an attribute consisting of a key (name) and an array of values.
Columnwith rendering metrics (as of the
ColumnSetupMetrics) mostly for text-based output such as for generating output for a terminal / console.
FormattedColumns<T> FormattedHeader<T> Header<T> HeaderAccessor<T>Provides an accessor for a
HeaderAccessor.HeaderBuilder<T extends HeaderAccessor.HeaderBuilder<?>>Provides a mutator for an header property. HeaderAccessor.HeaderMutator<T>Provides a mutator for a
HeaderRow<T,C extends Column<? extends T>> Record<T> RecordAccessor<T>Provides an accessor for a
RecordAccessor.RecordMutator<T>Provides a mutator for a
Recordswith functionality for file based implementations regarding header management and means to monitor the state of reading data.
Records<T> RecordsAccessor<T>Provides an accessor for a
RecordsAccessor.RecordsMutator<T>Provides a mutator for a
Class Summary Class Description AbstractColumn<T> AbstractHeader<T,C extends Column<? extends T>> CompositeRecords<T> CsvRecordReader<T> CsvRecordWriter<T>The
CsvStringRecordReader CsvStringRecordWriter DateColumnImpl ExceptionColumnImplThe Class ExceptionColumnImpl. FieldImpl<T> FieldsImpl<T> FormattedColumnDecorator<T>Decorator implementation of the HeaderSetupMetrics interface. FormattedColumnImpl<T>Implementation of the
FormattedHeaderImpl<T>The Class FormattedHeaderImpl. HeaderImpl<T> IntegerColumn IntegerColumnFactory ObjectColumn<T> ObjectColumnFactory RecordImpl<T> RecordsImpl<T> RowImpl<T> RowsImpl<T> StringColumn StringColumnFactory StringsColumn TabularUtilityUtility for listing specific functionality.
Enum Summary Enum Description PrintStackTraceThe Enum PrintStackTrace.
Exception Summary Exception Description ColumnMismatchException HeaderMismatchException TabularExceptionBase exception for the refcodes-tabular artifact. TabularRuntimeExceptionBase runtime exception for the refcodes-tabular artifact.