Module org.refcodes.tabular

Package org.refcodes.tabular

Interface HeaderRow<T,C extends Column<? extends T>>

Type Parameters:

T - The type managed by the HeaderRow.

C - the generic type

All Superinterfaces:

org.refcodes.mixin.Clearable, Collection<C>, ColumnRow<T,C>, Iterable<C>, org.refcodes.struct.Keys<String,C>, org.refcodes.struct.Keys.MutableKeys<String,C>, List<C>

All Known Subinterfaces:

FormattedHeader<T>, Header<T>

All Known Implementing Classes:

AbstractHeader, FormattedHeaderImpl, HeaderImpl, StringHeader

public interface HeaderRow<T,C extends Column<? extends T>>
extends ColumnRow<T,C>, List<C>

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 HeaderRow. The HeaderRow preserves an order for a list of Column instances. A HeaderRow provides the semantics for related Row instances.

The Keys.keySet() method must provide a predictable order as ensured by the LinkedHashSet class as of the ordered nature of the HeaderRow.

Nested Class Summary

Nested classes/interfaces inherited from interface org.refcodes.struct.Keys

org.refcodes.struct.Keys.MutableKeys<K extends Object,V extends Object>, org.refcodes.struct.Keys.MutableValues<K extends Object,V extends Object>

Method Summary

Modifier and Type	Method	Description
Record<T>	fromStorageString(Record<String> aStringRecord)	A special Column implementation might provide its own text exchange format for the given objects.
Row<T>	fromStorageString(Row<String> aStringRow)	A special Column implementation might provide its own text exchange format for the given objects.
Row<T>	fromStorageStringRecord(Record<String> aStringRecord)	A special Column implementation might provide its own text exchange format for the given objects.
Record<T>	fromStorageStringRow(Row<String> aStringRow)	A special Column implementation might provide its own text exchange format for the given objects.
Record<T>	fromStorageStrings(Record<String[]> aStringsRecord)	A special Column implementation might provide its own text exchange format for the given objects.
Row<T>	fromStorageStrings(Row<String[]> aStringsRow)	A special Column implementation might provide its own text exchange format for the given objects.
Row<T>	fromStorageStringsRecord(Record<String[]> aStringsRecord)	A special Column implementation might provide its own text exchange format for the given objects.
Record<T>	fromStorageStringsRow(Row<String[]> aStringsRow)	A special Column implementation might provide its own text exchange format for the given objects.
int	indexOf(String aKey)	Determines the index of the column with the given key or -1 if there is none such column.
Record<String>	toPrintable(Record<? extends T> aRecord)	A special Column implementation might provide its own printable format of the given objects; for example a human readable text representation of the value (or in very specialized cases even enriched with ANSI Escape-Codes).
Row<String>	toPrintable(Row<? extends T> aRow)	A special Column implementation might provide its own printable format of the given objects; for example a human readable text representation of the value (or in very specialized cases even enriched with ANSI Escape-Codes).
Record<String>	toPrintableRecord(Row<? extends T> aRow)	A special Column implementation might provide its own printable format of the given objects; for example a human readable text representation of the value (or in very specialized cases even enriched with ANSI Escape-Codes).
Row<String>	toPrintableRow(Record<? extends T> aRecord)	A special Column implementation might provide its own printable format of the given objects; for example a human readable text representation of the value (or in very specialized cases even enriched with ANSI Escape-Codes).
default Record<T>	toRecord(String... aRecord)	Converts the String elements to an according Record.
Record<T>	toRecord(Row<? extends T> aRow)	Creates a Record of the Row with the values in the order of the HeaderRow.
Record<?>	toRecordIgnoreType(Row<?> aRow)	Similar to toRecord(Row) with the difference that conversion is done ignoring the type of the HeaderRow Column instances and the according value(s).
Row<T>	toRow(Record<? extends T> aRecord)	Creates a Row of the Record with the values in the order of the HeaderRow.
Row<?>	toRowIgnoreType(Record<?> aRecord)	Similar to toRow(Record) with the difference that conversion is done ignoring the type of the HeaderRow Column instances and the according value(s).
Record<String>	toStorageString(Record<? extends T> aRecord)	A special Column implementation might provide its own text exchange format for the given objects.
Row<String>	toStorageString(Row<? extends T> aRow)	A special Column implementation might provide its own text exchange format for the given objects.
Record<String>	toStorageStringRecord(Row<? extends T> aRow)	A special Column implementation might provide its own text exchange format for the given objects.
Row<String>	toStorageStringRow(Record<? extends T> aRecord)	A special Column implementation might provide its own text exchange format for the given objects.
Record<String[]>	toStorageStrings(Record<? extends T> aRecord)	A special Column implementation might provide its own text exchange format for the given objects.
Row<String[]>	toStorageStrings(Row<? extends T> aRow)	A special Column implementation might provide its own text exchange format for the given objects.
Record<String[]>	toStorageStringsRecord(Row<? extends T> aRow)	A special Column implementation might provide its own text exchange format for the given objects.
Row<String[]>	toStorageStringsRow(Record<? extends T> aRecord)	A special Column implementation might provide its own text exchange format for the given objects.

Methods inherited from interface org.refcodes.mixin.Clearable

clear

Methods inherited from interface java.util.Collection

parallelStream, removeIf, stream, toArray

Methods inherited from interface org.refcodes.tabular.ColumnRow

containsValue, withColumns

Methods inherited from interface java.lang.Iterable

forEach

Methods inherited from interface org.refcodes.struct.Keys

containsKey, get, getOr, keySet, use, values

Methods inherited from interface org.refcodes.struct.Keys.MutableKeys

delete

Methods inherited from interface java.util.List

add, add, addAll, addAll, clear, contains, containsAll, equals, get, hashCode, indexOf, isEmpty, iterator, lastIndexOf, listIterator, listIterator, remove, remove, removeAll, replaceAll, retainAll, set, size, sort, spliterator, subList, toArray, toArray

Method Detail

indexOf

int indexOf(String aKey)

Determines the index of the column with the given key or -1 if there is none such column.

Parameters:

aKey - The key for which to get the column index.

Returns:

The index or -1 if there is none such column.

toRow

Row<T> toRow(Record<? extends T> aRecord)
      throws HeaderMismatchException,
             ColumnMismatchException

Creates a Row of the Record with the values in the order of the HeaderRow. This method is kind of "strong typed" as any type mismatch between the Column defined in the HeaderRow and the according value of the Record we get a ColumnMismatchException.

Parameters:

aRecord - The Record to use when creating the Row.

Returns:

The Row according to the Column instances of the HeaderRow.

Throws:

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 HeaderRow.

ColumnMismatchException - Thrown in case a value was found in the e.g. in a Record of the wrong type than specified by a Column of the HeaderRow.

toRowIgnoreType

Row<?> toRowIgnoreType(Record<?> aRecord)
                throws HeaderMismatchException

Similar to toRow(Record) with the difference that conversion is done ignoring the type of the HeaderRow Column instances and the according value(s).

Parameters:

aRecord - The Record to use when creating the Row.

Returns:

The Row according to the Column instances of the HeaderRow.

Throws:

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 HeaderRow.

toRecord

Record<T> toRecord(Row<? extends T> aRow)
            throws HeaderMismatchException,
                   ColumnMismatchException

Creates a Record of the Row with the values in the order of the HeaderRow. This method is kind of "strong typed" as any type mismatch between the Column defined in the HeaderRow and the according value of the Row we get a ColumnMismatchException.

Parameters:

aRow - The Record to use when creating the Record.

Returns:

The Row according to the Column instances of the HeaderRow.

Throws:

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 HeaderRow.

ColumnMismatchException - Thrown in case a value was found in the e.g. in a Record of the wrong type than specified by a Column of the HeaderRow.

toRecord

default Record<T> toRecord(String... aRecord)
                    throws HeaderMismatchException,
                           ParseException

Converts the String elements to an according Record.

Parameters:

aRecord - The String array to convert.

Returns:

The accordingly created Record;

Throws:

HeaderMismatchException - thrown in case there is a mismatch between the given Header and a Row (or another Header), i.e. the index for the given key in a header may be out of index of a given row or the given key does not exist in a Header.

ParseException - in case parsing the input was not possible

toRecordIgnoreType

Record<?> toRecordIgnoreType(Row<?> aRow)
                      throws HeaderMismatchException

Similar to toRecord(Row) with the difference that conversion is done ignoring the type of the HeaderRow Column instances and the according value(s).

Parameters:

aRow - The Record to use when creating the Record.

Returns:

The Row according to the Column instances of the HeaderRow.

Throws:

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 HeaderRow.

toStorageString

Row<String> toStorageString(Row<? extends T> aRow)
                     throws HeaderMismatchException,
                            ColumnMismatchException

A special Column implementation might provide its own text exchange format for the given objects. This method enables the HeaderRow to convert a Row of the given type to a Row containing only String values and via fromStorageString(Row) back to the actual Row (bijective). This method may use a Column instance's method Column.toStorageString(Object).

Parameters:

aRow - the Row to be converted to a String Row.

Returns:

The String representation of the value.

Throws:

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 HeaderRow.

ColumnMismatchException - Thrown in case a value was found in the e.g. in a Row of the wrong type than specified by a Column of the HeaderRow.

fromStorageString

Row<T> fromStorageString(Row<String> aStringRow)
                  throws HeaderMismatchException,
                         ParseException

A special Column implementation might provide its own text exchange format for the given objects. This method enables the HeaderRow to convert a Row containing only String objects to a Row with the given types and via toStorageString(Row) back to the String Row (bijective). This method may use a Column instance's method Column.fromStorageString(String).

Parameters:

aStringRow - the String Row to be converted to a type Row.

Returns:

The type representation of the value.

Throws:

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 HeaderRow.

ParseException - in case parsing the input was not possible

UnsupportedOperationException - in case this operation is not supported.

toStorageString

Record<String> toStorageString(Record<? extends T> aRecord)
                        throws HeaderMismatchException,
                               ColumnMismatchException

A special Column implementation might provide its own text exchange format for the given objects. This method enables the HeaderRow to convert a Record of the given type to a Record containing only String values and via fromStorageString(Record) back to the actual Record (bijective). This method may use a Column instance's method Column.toStorageString(Object).

Parameters:

aRecord - the Record to be converted to a String Record.

Returns:

The String representation of the value.

Throws:

HeaderMismatchException - Thrown in case there is a mismatch between the given Columns 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 HeaderRow.

ColumnMismatchException - Thrown in case a value was found in the e.g. in a Record of the wrong type than specified by a Column of the HeaderRow.

fromStorageString

Record<T> fromStorageString(Record<String> aStringRecord)
                     throws HeaderMismatchException,
                            ParseException

A special Column implementation might provide its own text exchange format for the given objects. This method enables the HeaderRow to convert a Record containing only String objects to a Record with the given types and via toStorageString(Record) back to the String Record (bijective). This method may use a Column instance's method Column.fromStorageString(String).

Parameters:

aStringRecord - the String Record to be converted to a type Record.

Returns:

The type representation of the value.

Throws:

HeaderMismatchException - Thrown in case there is a mismatch between the given Columns 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 HeaderRow.

ParseException - in case parsing the input was not possible

UnsupportedOperationException - in case this operation is not supported.

toStorageStrings

Row<String[]> toStorageStrings(Row<? extends T> aRow)
                        throws HeaderMismatchException,
                               ColumnMismatchException

A special Column implementation might provide its own text exchange format for the given objects. This method enables the HeaderRow to convert a Row of the given type to a Row containing only String arrays and via fromStorageStrings(Row) back to the actual Row (bijective). This method may use a Column instance's method Column.toStorageStrings(Object). Supporting String arrays enables to address data sinks which support multiple values in one filed (for example some NoSQL databases such as Amazon's simple DB supports multiple values in one row's entry).

Parameters:

aRow - the Row to be converted to a String Row.

Returns:

The String representation of the value.

Throws:

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 HeaderRow.

ColumnMismatchException - Thrown in case a value was found in the e.g. in a Row of the wrong type than specified by a Column of the HeaderRow.

fromStorageStrings

Row<T> fromStorageStrings(Row<String[]> aStringsRow)
                   throws HeaderMismatchException,
                          ParseException

A special Column implementation might provide its own text exchange format for the given objects. This method enables the HeaderRow to convert a Row containing only String objects to a Row with the given types and via toStorageStrings(Row) back to the String array Row (bijective). This method may use a Column instance's method Column.fromStorageStrings(String[]). Supporting String arrays enables to address data sinks which support multiple values in one filed (for example some NoSQL databases such as Amazon's simple DB supports multiple values in one row's entry).

Parameters:

aStringsRow - the String array Row to be converted to a type Row.

Returns:

The type representation of the value.

Throws:

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 HeaderRow.

ParseException - in case parsing the input was not possible

UnsupportedOperationException - in case this operation is not supported.

toStorageStrings

Record<String[]> toStorageStrings(Record<? extends T> aRecord)
                           throws HeaderMismatchException,
                                  ColumnMismatchException

A special Column implementation might provide its own text exchange format for the given objects. This method enables the HeaderRow to convert a Record of the given type to a Record containing only String arrays and via fromStorageStrings(Record) back to the actual Record (bijective). This method may use a Column instance's method Column.toStorageStrings(Object). Supporting String arrays enables to address data sinks which support multiple values in one filed (for example some NoSQL databases such as Amazon's simple DB supports multiple values in one row's entry).

Parameters:

aRecord - the Record to be converted to a String Record.

Returns:

The String representation of the value.

Throws:

HeaderMismatchException - Thrown in case there is a mismatch between the given Columns 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 HeaderRow.

ColumnMismatchException - Thrown in case a value was found in the e.g. in a Record of the wrong type than specified by a Column of the HeaderRow.

fromStorageStrings

Record<T> fromStorageStrings(Record<String[]> aStringsRecord)
                      throws HeaderMismatchException,
                             ParseException

A special Column implementation might provide its own text exchange format for the given objects. This method enables the HeaderRow to convert a Record containing only String objects to a Record with the given types and via toStorageStrings(Record) back to the String Record (bijective). This method may use a Column instance's method Column.fromStorageStrings(String[]). Supporting String arrays enables to address data sinks which support multiple values in one filed (for example some NoSQL databases such as Amazon's simple DB supports multiple values in one row's entry).

Parameters:

aStringsRecord - the String array Record to be converted to a type Record.

Returns:

The type representation of the value.

Throws:

HeaderMismatchException - Thrown in case there is a mismatch between the given Columns 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 HeaderRow.

ParseException - in case parsing the input was not possible

UnsupportedOperationException - in case this operation is not supported.

toPrintable

Record<String> toPrintable(Record<? extends T> aRecord)
                    throws HeaderMismatchException,
                           ColumnMismatchException

A special Column implementation might provide its own printable format of the given objects; for example a human readable text representation of the value (or in very specialized cases even enriched with ANSI Escape-Codes). This method enables the HeaderRow to convert a value of the given type to a human readable text. The human readable text, in comparison to the method toStorageString(Record) (or toStorageStrings(Record)) is not intended to be converted back to the actual value (not bijective). This method may use a Column instance's method Column.toPrintable(Object); it also might enrich the output of the Column.toPrintable(Object) with device specific additional data such as ANSI Escape-Codes and with information regarding the Record as a whole and not just be regarding a single value.

Parameters:

aRecord - the Record to be converted to a human readable text Record.

Returns:

The human readable representation of the Record.

Throws:

HeaderMismatchException - Thrown in case there is a mismatch between the given Columns 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 HeaderRow.

ColumnMismatchException - Thrown in case a value was found in the e.g. in a Record of the wrong type than specified by a Column of the HeaderRow.

toPrintable

Row<String> toPrintable(Row<? extends T> aRow)
                 throws HeaderMismatchException,
                        ColumnMismatchException

A special Column implementation might provide its own printable format of the given objects; for example a human readable text representation of the value (or in very specialized cases even enriched with ANSI Escape-Codes). This method enables the HeaderRow to convert a value of the given type to a human readable text. The human readable text, in comparison to the method toStorageString(Row) (or toStorageStrings(Row)) is not intended to be converted back to the actual value (not bijective). This method may use a Column instance's method Column.toPrintable(Object); it also might enrich the output of the Column.toPrintable(Object) with device specific additional data such as ANSI Escape-Codes and with information regarding the Row as a whole and not just be regarding a single value.

Parameters:

aRow - the Row to be converted to a human readable text Row.

Returns:

The human readable representation of the Row.

Throws:

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 HeaderRow.

ColumnMismatchException - Thrown in case a value was found in the e.g. in a Row of the wrong type than specified by a Column of the HeaderRow.

fromStorageStringRecord

Row<T> fromStorageStringRecord(Record<String> aStringRecord)
                        throws HeaderMismatchException,
                               ParseException

A special Column implementation might provide its own text exchange format for the given objects. This method enables the HeaderRow to convert a Record containing only String objects to a Row with the given types and via toStorageStringRecord(Row) back to the String Record (bijective). This method may use a Column instance's method Column.fromStorageString(String).

Parameters:

aStringRecord - the String Record to be converted to a type Row.

Returns:

The type Row representation of the String Record.

Throws:

ParseException - in case parsing the input was not possible

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 HeaderRow.

toStorageStringRecord

Record<String> toStorageStringRecord(Row<? extends T> aRow)
                              throws HeaderMismatchException,
                                     ColumnMismatchException

A special Column implementation might provide its own text exchange format for the given objects. This method enables the HeaderRow to convert a Row of the given type to a Record containing only String values and via fromStorageStringRecord(Record) back to the actual Row (bijective). This method may use a Column instance's method Column.toStorageString(Object).

Parameters:

aRow - The Row to be converted to a String Record.

Returns:

The String representation of the value.

Throws:

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 HeaderRow.

ColumnMismatchException - Thrown in case a value was found in the e.g. in a Row of the wrong type than specified by a Column of the HeaderRow.

fromStorageStringRow

Record<T> fromStorageStringRow(Row<String> aStringRow)
                        throws HeaderMismatchException,
                               ParseException

A special Column implementation might provide its own text exchange format for the given objects. This method enables the HeaderRow to convert a Row containing only String objects to a Record with the given types and via toStorageStringRow(Record) back to the String Row (bijective). This method may use a Column instance's method Column.fromStorageString(String).

Parameters:

aStringRow - the String Row to be converted to a type Record.

Returns:

The type representation of the value.

Throws:

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 HeaderRow.

ParseException - in case parsing the input was not possible

UnsupportedOperationException - in case this operation is not supported.

toStorageStringRow

Row<String> toStorageStringRow(Record<? extends T> aRecord)
                        throws HeaderMismatchException,
                               ColumnMismatchException

A special Column implementation might provide its own text exchange format for the given objects. This method enables the HeaderRow to convert a Record of the given type to a Row containing only String values and via fromStorageStringRecord(Record) back to the actual Record (bijective). This method may use a Column instance's method Column.toStorageString(Object).

Parameters:

aRecord - The Row to be converted to a String Record.

Returns:

The String representation of the value.

Throws:

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 HeaderRow.

ColumnMismatchException - Thrown in case a value was found in the e.g. in a Record of the wrong type than specified by a Column of the HeaderRow.

fromStorageStringsRecord

Row<T> fromStorageStringsRecord(Record<String[]> aStringsRecord)
                         throws HeaderMismatchException,
                                ParseException

A special Column implementation might provide its own text exchange format for the given objects. This method enables the HeaderRow to convert a Record containing only String arrays to a Row with the given types and via toStorageStringsRecord(Row) back to the String Record (bijective). This method may use a Column instance's method Column.fromStorageStrings(String[]). Supporting String arrays enables to address data sinks which support multiple values in one filed (for example some NoSQL databases such as Amazon's simple DB supports multiple values in one row's entry).

Parameters:

aStringsRecord - the String Record to be converted to a type Row.

Returns:

The type Row representation of the String Record.

Throws:

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 HeaderRow.

ParseException - in case parsing the input was not possible

toStorageStringsRecord

Record<String[]> toStorageStringsRecord(Row<? extends T> aRow)
                                 throws HeaderMismatchException,
                                        ColumnMismatchException

A special Column implementation might provide its own text exchange format for the given objects. This method enables the HeaderRow to convert a Row of the given type to a Record containing only String arrays and via fromStorageStringsRecord(Record) back to the actual Row (bijective). This method may use a Column instance's method Column.toStorageStrings(Object). Supporting String arrays enables to address data sinks which support multiple values in one filed (for example some NoSQL databases such as Amazon's simple DB supports multiple values in one row's entry).

Parameters:

aRow - The Row to be converted to a String Record.

Returns:

The String representation of the value.

Throws:

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 HeaderRow.

ColumnMismatchException - Thrown in case a value was found in the e.g. in a Row of the wrong type than specified by a Column of the HeaderRow.

fromStorageStringsRow

Record<T> fromStorageStringsRow(Row<String[]> aStringsRow)
                         throws HeaderMismatchException,
                                ParseException

A special Column implementation might provide its own text exchange format for the given objects. This method enables the HeaderRow to convert a Row containing only String arrays to a Record with the given types and via toStorageStringsRow(Record) back to the String Row (bijective). This method may use a Column instance's method Column.fromStorageStrings(String[]). Supporting String arrays enables to address data sinks which support multiple values in one filed (for example some NoSQL databases such as Amazon's simple DB supports multiple values in one row's entry).

Parameters:

aStringsRow - the String Row to be converted to a type Record.

Returns:

The type representation of the value.

Throws:

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 HeaderRow.

ParseException - in case parsing the input was not possible

UnsupportedOperationException - in case this operation is not supported.

toStorageStringsRow

Row<String[]> toStorageStringsRow(Record<? extends T> aRecord)
                           throws HeaderMismatchException,
                                  ColumnMismatchException

A special Column implementation might provide its own text exchange format for the given objects. This method enables the HeaderRow to convert a Record of the given type to a Row containing only String arrays and via fromStorageStringsRecord(Record) back to the actual Record (bijective). This method may use a Column instance's method Column.toStorageStrings(Object). Supporting String arrays enables to address data sinks which support multiple values in one filed (for example some NoSQL databases such as Amazon's simple DB supports multiple values in one row's entry).

Parameters:

aRecord - The Row to be converted to a String Record.

Returns:

The String representation of the value.

Throws:

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 HeaderRow.

ColumnMismatchException - Thrown in case a value was found in the e.g. in a Record of the wrong type than specified by a Column of the HeaderRow.

toPrintableRow

Row<String> toPrintableRow(Record<? extends T> aRecord)
                    throws HeaderMismatchException,
                           ColumnMismatchException

A special Column implementation might provide its own printable format of the given objects; for example a human readable text representation of the value (or in very specialized cases even enriched with ANSI Escape-Codes). This method enables the HeaderRow to convert a value of the given type to a human readable text. The human readable text, in comparison to the method toRow(Record) (or toStorageStringsRecord(Row) is not intended to be converted back to the actual value (not bijective). This method may use a Column instance's method Column.toPrintable(Object); it also might enrich the output of the Column.toPrintable(Object) with device specific additional data such as ANSI Escape-Codes and with information regarding the Record as a whole and not just be regarding a single value.

Parameters:

aRecord - the Record to be converted to a human readable text Row.

Returns:

The human readable Row representation of the Record.

Throws:

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 HeaderRow.

ColumnMismatchException - Thrown in case a value was found in the e.g. in a Record of the wrong type than specified by a Column of the HeaderRow.

toPrintableRecord

Record<String> toPrintableRecord(Row<? extends T> aRow)
                          throws HeaderMismatchException,
                                 ColumnMismatchException

A special Column implementation might provide its own printable format of the given objects; for example a human readable text representation of the value (or in very specialized cases even enriched with ANSI Escape-Codes). This method enables the HeaderRow to convert a Row of the given type to a human readable text Record. The human readable text, in comparison to the method toStorageString(Row) (or toRecordIgnoreType(Row)) is not intended to be converted back to the actual value (not bijective). This method may use a Column instance's method Column.toPrintable(Object); it also might enrich the output of the Column.toPrintable(Object) with device specific additional data such as ANSI Escape-Codes and with information regarding the Row as a whole and not just be regarding a single value.

Parameters:

aRow - the Row to be converted to a human readable text Record.

Returns:

The human readable Record representation of the Row.

Throws:

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 HeaderRow.

ColumnMismatchException - Thrown in case a value was found in the e.g. in a Row of the wrong type than specified by a Column of the HeaderRow.