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:

java.lang.Cloneable, java.lang.Iterable<T>, java.util.Collection<T>, java.util.List<T>, org.refcodes.structure.Clearable, org.refcodes.structure.Keys<T,C>, org.refcodes.structure.Keys.MutableKeys<T,C>, ColumnRow<T,C>, HeaderRow<T,C>

Direct Known Subclasses:

FormattedHeaderImpl, HeaderImpl

public abstract class AbstractHeader<T,C extends Column<? extends T>>
extends java.util.ArrayList<C>
implements HeaderRow<T,C>, java.lang.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 java.lang.Object,V extends java.lang.Object>, org.refcodes.structure.Keys.MutableValues<K extends java.lang.Object,V extends java.lang.Object>

Field Summary

Fields

Modifier and Type	Field	Description
protected java.util.Set<java.lang.String>	_keys	A LinkedHashSet is used in order to preserve the order of the elements as contained in the Header itself.

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(java.lang.Object aKey)
C	delete(java.lang.String aKey)
Record<T>	fromStorageString(Record<java.lang.String> aStringRecord)	A special Column implementation might provide its own text exchange format for the given objects.
Row<T>	fromStorageString(Row<java.lang.String> aStringRow)	A special Column implementation might provide its own text exchange format for the given objects.
Row<T>	fromStorageStringRecord(Record<java.lang.String> aStringRecord)	A special Column implementation might provide its own text exchange format for the given objects.
Record<T>	fromStorageStringRow(Row<java.lang.String> aStringRow)	A special Column implementation might provide its own text exchange format for the given objects.
Record<T>	fromStorageStrings(Record<java.lang.String[]> aStringsRecord)	A special Column implementation might provide its own text exchange format for the given objects.
Row<T>	fromStorageStrings(Row<java.lang.String[]> aStringsRow)	A special Column implementation might provide its own text exchange format for the given objects.
Row<T>	fromStorageStringsRecord(Record<java.lang.String[]> aStringsRecord)	A special Column implementation might provide its own text exchange format for the given objects.
Record<T>	fromStorageStringsRow(Row<java.lang.String[]> aStringsRow)	A special Column implementation might provide its own text exchange format for the given objects.
C	get(java.lang.Object aKey)
int	indexOf(java.lang.String aKey)	Determines the index of the column with the given key or -1 if there is none such column.
java.util.Set<java.lang.String>	keySet()
Record<java.lang.String>	toPrintable(Record<? extends T> aRecord)	To printable.
Row<java.lang.String>	toPrintable(Row<? extends T> aRow)	To printable.
Record<java.lang.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<java.lang.String>	toPrintableRow(Record<? extends T> aRecord)	To printable row.
Record<T>	toRecord(Row<? extends T> aRow)	To record.
Record<?>	toRecordIgnoreType(Row<?> aRow)	Similar to HeaderRow.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)	To row.
Row<?>	toRowIgnoreType(Record<?> aRecord)	Similar to HeaderRow.toRow(Record) with the difference that conversion is done ignoring the type of the HeaderRow Column instances and the according value(s).
Record<java.lang.String>	toStorageString(Record<? extends T> aRecord)	To storage string.
Row<java.lang.String>	toStorageString(Row<? extends T> aRow)	To storage string.
Record<java.lang.String>	toStorageStringRecord(Row<? extends T> aRow)	A special Column implementation might provide its own text exchange format for the given objects.
Row<java.lang.String>	toStorageStringRow(Record<? extends T> aRecord)	A special Column implementation might provide its own text exchange format for the given objects.
Record<java.lang.String[]>	toStorageStrings(Record<? extends T> aRecord)	To storage strings.
Row<java.lang.String[]>	toStorageStrings(Row<? extends T> aRow)	To storage strings.
Record<java.lang.String[]>	toStorageStringsRecord(Row<? extends T> aRow)	A special Column implementation might provide its own text exchange format for the given objects.
Row<java.lang.String[]>	toStorageStringsRow(Record<? extends T> aRecord)	A special Column implementation might provide its own text exchange format for the given objects.
java.util.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.ColumnRow

containsValue, withColumns

Methods inherited from interface java.lang.Iterable

forEach

Methods inherited from interface org.refcodes.structure.Keys

getOr, 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

Field Detail

_keys

protected java.util.Set<java.lang.String> _keys

A LinkedHashSet is used in order to preserve the order of the elements as contained in the Header itself.

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(java.lang.Object aKey)

Specified by:

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

get

public C get(java.lang.Object aKey)

Specified by:

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

keySet

public java.util.Set<java.lang.String> keySet()

Specified by:

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

indexOf

public int indexOf(java.lang.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 HeaderRow<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(java.lang.String aKey)

Specified by:

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

toStorageString

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

To storage string.

Specified by:

toStorageString in interface HeaderRow<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<java.lang.String> toStorageString(Row<? extends T> aRow)
                                      throws HeaderMismatchException,
                                             ColumnMismatchException

To storage string.

Specified by:

toStorageString in interface HeaderRow<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<java.lang.String> aStringRecord)
                            throws HeaderMismatchException,
                                   java.text.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 HeaderRow.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 HeaderRow<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 HeaderRow.

java.text.ParseException - in case parsing the input was not possible

fromStorageString

public Row<T> fromStorageString(Row<java.lang.String> aStringRow)
                         throws HeaderMismatchException,
                                java.text.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 HeaderRow.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 HeaderRow<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 HeaderRow.

java.text.ParseException - in case parsing the input was not possible

toStorageStrings

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

To storage strings.

Specified by:

toStorageStrings in interface HeaderRow<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<java.lang.String[]> toStorageStrings(Row<? extends T> aRow)
                                         throws HeaderMismatchException,
                                                ColumnMismatchException

To storage strings.

Specified by:

toStorageStrings in interface HeaderRow<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<java.lang.String[]> aStringsRow)
                          throws HeaderMismatchException,
                                 java.text.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 HeaderRow.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 HeaderRow<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 HeaderRow.

java.text.ParseException - in case parsing the input was not possible

fromStorageStrings

public Record<T> fromStorageStrings(Record<java.lang.String[]> aStringsRecord)
                             throws HeaderMismatchException,
                                    java.text.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 HeaderRow.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 HeaderRow<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 HeaderRow.

java.text.ParseException - in case parsing the input was not possible

toPrintable

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

To printable.

Specified by:

toPrintable in interface HeaderRow<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<java.lang.String> toPrintable(Row<? extends T> aRow)
                                  throws HeaderMismatchException,
                                         ColumnMismatchException

To printable.

Specified by:

toPrintable in interface HeaderRow<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 HeaderRow<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 HeaderRow.toRow(Record) with the difference that conversion is done ignoring the type of the HeaderRow Column instances and the according value(s).

Specified by:

toRowIgnoreType in interface HeaderRow<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 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

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

To record.

Specified by:

toRecord in interface HeaderRow<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 HeaderRow.toRecord(Row) with the difference that conversion is done ignoring the type of the HeaderRow Column instances and the according value(s).

Specified by:

toRecordIgnoreType in interface HeaderRow<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 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.

fromStorageStringRecord

public Row<T> fromStorageStringRecord(Record<java.lang.String> aStringRecord)
                               throws HeaderMismatchException,
                                      java.text.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 HeaderRow.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 HeaderRow<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 HeaderRow.

java.text.ParseException - in case parsing the input was not possible

toStorageStringRecord

public Record<java.lang.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 HeaderRow.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 HeaderRow<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 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

public Record<T> fromStorageStringRow(Row<java.lang.String> aStringRow)
                               throws HeaderMismatchException,
                                      java.text.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 HeaderRow.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 HeaderRow<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 HeaderRow.

java.text.ParseException - in case parsing the input was not possible

toStorageStringRow

public Row<java.lang.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 HeaderRow.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 HeaderRow<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 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

public Row<T> fromStorageStringsRecord(Record<java.lang.String[]> aStringsRecord)
                                throws HeaderMismatchException,
                                       java.text.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 HeaderRow.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 HeaderRow<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 HeaderRow.

java.text.ParseException - in case parsing the input was not possible

toStorageStringsRecord

public Record<java.lang.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 HeaderRow.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 HeaderRow<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 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

public Record<T> fromStorageStringsRow(Row<java.lang.String[]> aStringsRow)
                                throws HeaderMismatchException,
                                       java.text.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 HeaderRow.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 HeaderRow<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 HeaderRow.

java.text.ParseException - in case parsing the input was not possible

toStorageStringsRow

public Row<java.lang.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 HeaderRow.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 HeaderRow<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 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

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

To printable row.

Specified by:

toPrintableRow in interface HeaderRow<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<java.lang.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 HeaderRow.toStorageString(Row) (or HeaderRow.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 HeaderRow<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 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.

add

public boolean add(C aColumn)

Specified by:

add in interface java.util.Collection<T>

Specified by:

add in interface java.util.List<T>

Overrides:

add in class java.util.ArrayList<C extends Column<? extends T>>

add

public void add(int aIndex,
                C aColumn)

Specified by:

add in interface java.util.List<T>

Overrides:

add in class java.util.ArrayList<C extends Column<? extends T>>

values

public java.util.Collection<C> values()

Specified by:

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