Package org.refcodes.tabular

Class AbstractHeader<T,C extends Column<? extends T>>

java.lang.Object

java.util.AbstractCollection<E>

java.util.AbstractList<E>

java.util.ArrayList<C>

org.refcodes.tabular.AbstractHeader<T,C>

Type Parameters:

T - The type managed by the Header.

C - the generic type

All Implemented Interfaces:

Serializable, Cloneable, Iterable<T>, Collection<T>, List<T>, RandomAccess, org.refcodes.structure.Clearable, org.refcodes.structure.Keys<T,C>, org.refcodes.structure.Keys.MutableKeys<T,C>, ColumnsTemplate<T,C>, HeaderTemplate<T,C>

Direct Known Subclasses:

FormattedHeaderImpl, HeaderImpl

public abstract class AbstractHeader<T,C extends Column<? extends T>>
extends ArrayList<C>
implements HeaderTemplate<T,C>, Cloneable

Implementation of the Header interface being Cloneable.

See Also:

Serialized Form

Nested Class Summary

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

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

Field Summary

Fields inherited from class java.util.AbstractList

modCount

Constructor Summary

Constructors

Constructor	Description
AbstractHeader()	Constructs the AbstractHeader instance.
AbstractHeader(C... aHeader)	Constructs the AbstractHeader instance configured with the provided Column instances.

Method Summary

Modifier and Type	Method	Description
void	add(int aIndex, C aColumn)
boolean	add(C aColumn)
boolean	containsKey(Object aKey)
C	delete(String aKey)
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.
C	get(Object aKey)
int	indexOf(String aKey)	Determines the index of the column with the given key or -1 if there is none such column.
Set<String>	keySet()
Record<String>	toPrintable(Record<? extends T> aRecord)	To printable.
Row<String>	toPrintable(Row<? extends T> aRow)	To printable.
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)	To printable row.
Record<T>	toRecord(Row<? extends T> aRow)	To record.
Record<?>	toRecordIgnoreType(Row<?> aRow)	Similar to HeaderTemplate.toRecord(Row) with the difference that conversion is done ignoring the type of the HeaderTemplate Column instances and the according value(s).
Row<T>	toRow(Record<? extends T> aRecord)	To row.
Row<?>	toRowIgnoreType(Record<?> aRecord)	Similar to HeaderTemplate.toRow(Record) with the difference that conversion is done ignoring the type of the HeaderTemplate Column instances and the according value(s).
Record<String>	toStorageString(Record<? extends T> aRecord)	To storage string.
Row<String>	toStorageString(Row<? extends T> aRow)	To storage string.
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)	To storage strings.
Row<String[]>	toStorageStrings(Row<? extends T> aRow)	To storage strings.
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.
Collection<C>	values()

Methods inherited from class java.util.AbstractCollection

containsAll, toString

Methods inherited from class java.util.AbstractList

equals, hashCode

Methods inherited from class java.util.ArrayList

addAll, addAll, clear, clone, contains, ensureCapacity, forEach, get, indexOf, isEmpty, iterator, lastIndexOf, listIterator, listIterator, remove, remove, removeAll, removeIf, removeRange, replaceAll, retainAll, set, size, sort, spliterator, subList, toArray, toArray, trimToSize

Methods inherited from interface org.refcodes.structure.Clearable

clear

Methods inherited from interface java.util.Collection

parallelStream, removeIf, stream

Methods inherited from interface org.refcodes.tabular.ColumnsTemplate

containsValue, withColumns

Methods inherited from interface java.lang.Iterable

forEach

Methods inherited from interface org.refcodes.structure.Keys

get, use

Methods inherited from interface java.util.List

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

Methods inherited from class java.lang.Object

finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

AbstractHeader

public AbstractHeader()

Constructs the AbstractHeader instance.

AbstractHeader

@SafeVarargs
public AbstractHeader(C... aHeader)

Constructs the AbstractHeader instance configured with the provided Column instances.

Parameters:

aHeader - The Column instances to be contained in the AbstractHeader in the order as passed.

Method Detail

containsKey

public boolean containsKey(Object aKey)

Specified by:

containsKey in interface org.refcodes.structure.Keys<T,C extends Column<? extends T>>

get

public C get(Object aKey)

Specified by:

get in interface org.refcodes.structure.Keys<T,C extends Column<? extends T>>

keySet

public Set<String> keySet()

Specified by:

keySet in interface org.refcodes.structure.Keys<T,C extends Column<? extends T>>

indexOf

public int indexOf(String aKey)

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

Specified by:

indexOf in interface HeaderTemplate<T,C extends Column<? extends T>>

Parameters:

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

Returns:

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

delete

public C delete(String aKey)

Specified by:

delete in interface org.refcodes.structure.Keys.MutableKeys<T,C extends Column<? extends T>>

toStorageString

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

To storage string.

Specified by:

toStorageString in interface HeaderTemplate<T,C extends Column<? extends T>>

Parameters:

aRecord - the record

Returns:

the record

Throws:

HeaderMismatchException - the header mismatch exception

ColumnMismatchException - the column mismatch exception

toStorageString

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

To storage string.

Specified by:

toStorageString in interface HeaderTemplate<T,C extends Column<? extends T>>

Parameters:

aRow - the row

Returns:

the row

Throws:

HeaderMismatchException - the header mismatch exception

ColumnMismatchException - the column mismatch exception

fromStorageString

public 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 HeaderTemplate to convert a Record containing only String objects to a Record with the given types and via HeaderTemplate.toStorageString(Record) back to the String Record (bijective). This method may use a Column instance's method Column.fromStorageString(String).

Specified by:

fromStorageString in interface HeaderTemplate<T,C extends Column<? extends T>>

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

ParseException - in case parsing the input was not possible

fromStorageString

public 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 HeaderTemplate to convert a Row containing only String objects to a Row with the given types and via HeaderTemplate.toStorageString(Row) back to the String Row (bijective). This method may use a Column instance's method Column.fromStorageString(String).

Specified by:

fromStorageString in interface HeaderTemplate<T,C extends Column<? extends T>>

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

ParseException - in case parsing the input was not possible

toStorageStrings

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

To storage strings.

Specified by:

toStorageStrings in interface HeaderTemplate<T,C extends Column<? extends T>>

Parameters:

aRecord - the record

Returns:

the record

Throws:

HeaderMismatchException - the header mismatch exception

ColumnMismatchException - the column mismatch exception

toStorageStrings

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

To storage strings.

Specified by:

toStorageStrings in interface HeaderTemplate<T,C extends Column<? extends T>>

Parameters:

aRow - the row

Returns:

the row

Throws:

HeaderMismatchException - the header mismatch exception

ColumnMismatchException - the column mismatch exception

fromStorageStrings

public 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 HeaderTemplate to convert a Row containing only String objects to a Row with the given types and via HeaderTemplate.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).

Specified by:

fromStorageStrings in interface HeaderTemplate<T,C extends Column<? extends T>>

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

ParseException - in case parsing the input was not possible

fromStorageStrings

public 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 HeaderTemplate to convert a Record containing only String objects to a Record with the given types and via HeaderTemplate.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).

Specified by:

fromStorageStrings in interface HeaderTemplate<T,C extends Column<? extends T>>

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

ParseException - in case parsing the input was not possible

toPrintable

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

To printable.

Specified by:

toPrintable in interface HeaderTemplate<T,C extends Column<? extends T>>

Parameters:

aRecord - the record

Returns:

the record

Throws:

HeaderMismatchException - the header mismatch exception

ColumnMismatchException - the column mismatch exception

toPrintable

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

To printable.

Specified by:

toPrintable in interface HeaderTemplate<T,C extends Column<? extends T>>

Parameters:

aRow - the row

Returns:

the row

Throws:

HeaderMismatchException - the header mismatch exception

ColumnMismatchException - the column mismatch exception

toRow

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

To row.

Specified by:

toRow in interface HeaderTemplate<T,C extends Column<? extends T>>

Parameters:

aRecord - the record

Returns:

the row

Throws:

HeaderMismatchException - the header mismatch exception

ColumnMismatchException - the column mismatch exception

toRowIgnoreType

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

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

Specified by:

toRowIgnoreType in interface HeaderTemplate<T,C extends Column<? extends T>>

Parameters:

aRecord - The Record to use when creating the Row.

Returns:

The Row according to the Column instances of the HeaderTemplate.

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

toRecord

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

To record.

Specified by:

toRecord in interface HeaderTemplate<T,C extends Column<? extends T>>

Parameters:

aRow - the row

Returns:

the record

Throws:

HeaderMismatchException - the header mismatch exception

ColumnMismatchException - the column mismatch exception

toRecordIgnoreType

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

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

Specified by:

toRecordIgnoreType in interface HeaderTemplate<T,C extends Column<? extends T>>

Parameters:

aRow - The Record to use when creating the Record.

Returns:

The Row according to the Column instances of the HeaderTemplate.

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

fromStorageStringRecord

public 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 HeaderTemplate to convert a Record containing only String objects to a Row with the given types and via HeaderTemplate.toStorageStringRecord(Row) back to the String Record (bijective). This method may use a Column instance's method Column.fromStorageString(String).

Specified by:

fromStorageStringRecord in interface HeaderTemplate<T,C extends Column<? extends T>>

Parameters:

aStringRecord - 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 HeaderTemplate.

ParseException - in case parsing the input was not possible

toStorageStringRecord

public 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 HeaderTemplate to convert a Row of the given type to a Record containing only String values and via HeaderTemplate.fromStorageStringRecord(Record) back to the actual Row (bijective). This method may use a Column instance's method Column.toStorageString(Object). ------------------------------------------------------------------------- TODO !!! STILL TO BE TESTED !!! -------------------------------------------------------------------------

Specified by:

toStorageStringRecord in interface HeaderTemplate<T,C extends Column<? extends T>>

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

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

fromStorageStringRow

public 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 HeaderTemplate to convert a Row containing only String objects to a Record with the given types and via HeaderTemplate.toStorageStringRow(Record) back to the String Row (bijective). This method may use a Column instance's method Column.fromStorageString(String).

Specified by:

fromStorageStringRow in interface HeaderTemplate<T,C extends Column<? extends T>>

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

ParseException - in case parsing the input was not possible

toStorageStringRow

public 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 HeaderTemplate to convert a Record of the given type to a Row containing only String values and via HeaderTemplate.fromStorageStringRecord(Record) back to the actual Record (bijective). This method may use a Column instance's method Column.toStorageString(Object). ------------------------------------------------------------------------- TODO !!! STILL TO BE TESTED !!! -------------------------------------------------------------------------

Specified by:

toStorageStringRow in interface HeaderTemplate<T,C extends Column<? extends T>>

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

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

fromStorageStringsRecord

public 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 HeaderTemplate to convert a Record containing only String arrays to a Row with the given types and via HeaderTemplate.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).

Specified by:

fromStorageStringsRecord in interface HeaderTemplate<T,C extends Column<? extends T>>

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

ParseException - in case parsing the input was not possible

toStorageStringsRecord

public 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 HeaderTemplate to convert a Row of the given type to a Record containing only String arrays and via HeaderTemplate.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). ------------------------------------------------------------------------- TODO !!! STILL TO BE TESTED !!! -------------------------------------------------------------------------

Specified by:

toStorageStringsRecord in interface HeaderTemplate<T,C extends Column<? extends T>>

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

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

fromStorageStringsRow

public 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 HeaderTemplate to convert a Row containing only String arrays to a Record with the given types and via HeaderTemplate.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).

Specified by:

fromStorageStringsRow in interface HeaderTemplate<T,C extends Column<? extends T>>

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

ParseException - in case parsing the input was not possible

toStorageStringsRow

public 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 HeaderTemplate to convert a Record of the given type to a Row containing only String arrays and via HeaderTemplate.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). ------------------------------------------------------------------------- TODO !!! STILL TO BE TESTED !!! -------------------------------------------------------------------------

Specified by:

toStorageStringsRow in interface HeaderTemplate<T,C extends Column<? extends T>>

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

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

toPrintableRow

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

To printable row.

Specified by:

toPrintableRow in interface HeaderTemplate<T,C extends Column<? extends T>>

Parameters:

aRecord - the record

Returns:

the row

Throws:

HeaderMismatchException - the header mismatch exception

ColumnMismatchException - the column mismatch exception

toPrintableRecord

public 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 HeaderTemplate to convert a Row of the given type to a human readable text Record. The human readable text, in comparison to the method HeaderTemplate.toStorageString(Row) (or HeaderTemplate.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. ------------------------------------------------------------------------- TODO !!! STILL TO BE TESTED !!! -------------------------------------------------------------------------

Specified by:

toPrintableRecord in interface HeaderTemplate<T,C extends Column<? extends T>>

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

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

add

public boolean add(C aColumn)

Specified by:

add in interface Collection<T>

Specified by:

add in interface List<T>

Overrides:

add in class ArrayList<C extends Column<? extends T>>

add

public void add(int aIndex,
                C aColumn)

Specified by:

add in interface List<T>

Overrides:

add in class ArrayList<C extends Column<? extends T>>

values

public Collection<C> values()

Specified by:

values in interface org.refcodes.structure.Keys<T,C extends Column<? extends T>>