See: Description
Interface | Description |
---|---|
Column<T> | |
ColumnAccessor<T> |
Provides an accessor for a
Column property. |
ColumnAccessor.ColumnMutator<T> |
Provides a mutator for a
Column property. |
ColumnAccessor.ColumnProperty<T> |
Provides a
Column property. |
ColumnFactory<T> |
A
ColumnFactory creates or retrieves a Column instances
identified by the provided key (name). |
Columns<T> | |
ColumnsTemplate<T,C extends Column<? extends T>> |
In case no order of the
Column instances is explicitly required
(similar to a DB table or a spread sheet, in contrast to a CSV file) then
Column instances are grouped by a ColumnsTemplate set. |
Field<T> |
A
Field stores an attribute consisting of a key (name) and a value. |
Fields<T> |
A
Fields stores an attribute consisting of a key (name) and an array
of values. |
FormattedColumn<T> |
Enriches a
Column with rendering metrics (as of the
ColumnSetupMetrics ) mostly for text-based output such as for
generating output for a terminal / console. |
FormattedColumns<T> |
In case no order of the
FormattedColumn instances is explicitly
required (similar to a DB table or a spread sheet, in contrast to a CSV file)
then FormattedColumn instances are grouped by a
FormattedColumns set. |
FormattedHeader<T> |
A list of
Column instances, for example describing the elements of a
CSV file (visually speaking the of the CSV file's header line), is
represented by the FormattedHeader . |
Header<T> | |
HeaderAccessor<T> |
Provides an accessor for a
Header property. |
HeaderAccessor.HeaderBuilder<T extends HeaderAccessor.HeaderBuilder<?>> |
Provides a mutator for an header property.
|
HeaderAccessor.HeaderMutator<T> |
Provides a mutator for a
Header property. |
HeaderAccessor.HeaderProperty<T> |
Provides a
Header property. |
HeaderTemplate<T,C extends Column<? extends T>> |
A list of
Column instances, for example describing the elements of a
CSV file (visually speaking the of the CSV file's header line), is
represented by the HeaderTemplate . |
InputStreamRecords<T> |
Extends the
Records with means to monitor the state of file based
implementations. |
Record<T> | |
RecordAccessor<T> |
Provides an accessor for a
Record property. |
RecordAccessor.RecordMutator<T> |
Provides a mutator for a
Record property. |
RecordAccessor.RecordProperty<T> |
Provides a
Record property. |
Records<T> | |
RecordsAccessor<T> |
Provides an accessor for a
Records property. |
RecordsAccessor.RecordsMutator<T> |
Provides a mutator for a
Records property. |
RecordsAccessor.RecordsProperty<T> |
Provides a
Records property. |
Row<T> | |
Rows<T> |
Class | Description |
---|---|
TabularUtility |
Utility for listing specific functionality.
|
Enum | Description |
---|---|
PrintStackTrace |
The Enum PrintStackTrace.
|
Exception | Description |
---|---|
ColumnMismatchException | |
HeaderMismatchException |
Thrown in case there is a mismatch between the given
HeaderMismatchException and the Row , i.e. the index for the
given key in the header may be out of index of the given row or the given key
does not exist in the Header . |
TabularException |
Base exception for the refcodes-tabular artifact.
|
TabularRuntimeException |
Base runtime exception for the refcodes-tabular artifact.
|
Column
:Column
describes
properties such as name (key) and type of elements related to that
Column
(e.g. the according elements of the
Row
lines).
Header
:Column
instances, for example
describing the elements of a CSV file (visually speaking the of the CSV
file's header line), is represented by the
Header
. The Header
preserves an order for a list of Column
instances. A Header
provides the semantics for
related Row
instances.
Header
:Column
instances is
explicitly required (similar to a DB table or a spread sheet, in contrast to
a CSV file) then Column
instances are grouped by
a Header
set.
Header
provide additional semantics to the
Field
instances stored in a
Record
.
Row
:Row
holds multiple data elements loosely
coupled to a Header
. As a
Row
just contains a list of data elements with
no keys (names) directly associated to the elements, a
Header
with the according list of key (name) and
type definitions is required to give a Row
its
semantics.
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
Header
.
Many 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
, a
Record
relates an element field with a key
(name), called Field
.
In contrast to a Record
, a
Row
does not relate a key (name) to its values.
To do this, a Header
is required. Similar to a
Record
, a Row
makes
use of Column
instances (provided by a
Header
instance) to give the fields additional
semantics.
Rows
:Row
instances is represented by a
Rows
instance. As of efficiency reasons, a
Rows
instance can be iterated through, returning
a single Row
within each iteration. This
approach is making it possible to query a DB in the background and just hold
the Row
instances being served next in the
Rows
instance (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
retrieve the Row
instances in blocks one by one,
one after the other, by querying the DB accordingly (in terms of "next"
result sets).
Record
:Record
is a Map
containing
Field
data structures with support for
Column
definitions. The
Field
instances can be managed with the
functionality provided by a Column
.
A value can be retrieved from a Record
by
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
Column
instances.
In contrast to a Row
, a
Record
relates the key (name) to its values.
Similar to a Row
, a
Record
makes use of
Column
instances (for example as provided by a
Header
or a Header
instance) to give the fields additional semantics.
Records
:Record
instances is represented by a
Records
instance. As of efficiency reasons, a
Records
instance can be iterated through,
returning a single Record
within each iteration.
This approach is making it possible to query a DB in the background and just
hold the Record
instances being served next in
the Records
instance (in memory).
The way how Records
instances manage their
related Record
instances is implementation
specific, a plain java implementation might use some kind of collection for
storing the Record
instances (this can get
memory intensive and not applicable when working with big data). A DB
implementation might retrieve the Record
instances in blocks one by one, one after the other, by querying the DB
accordingly (in terms of "next" result sets).
Copyright © 2017. All rights reserved.