Module org.refcodes.tabular
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 theHeader
.C
- the generic type
- All Implemented Interfaces:
Serializable
,Cloneable
,Iterable<C>
,Collection<C>
,List<C>
,RandomAccess
,org.refcodes.mixin.Clearable
,org.refcodes.struct.Keys<String,
,C> org.refcodes.struct.Keys.MutableKeys<String,
,C> ColumnRow<T,
,C> HeaderRow<T,
C>
- Direct Known Subclasses:
FormattedHeader
,HeaderImpl
public abstract class AbstractHeader<T,C extends Column<? extends T>>
extends ArrayList<C>
implements HeaderRow<T,C>, Cloneable
- See Also:
-
Nested Class Summary
-
Field Summary
Modifier and TypeFieldDescriptionALinkedHashSet
is used in order to preserve the order of the elements as contained in theHeader
itself.Fields inherited from class java.util.AbstractList
modCount
-
Constructor Summary
ConstructorDescriptionConstructs theAbstractHeader
instance.AbstractHeader
(C... aColumns) Constructs theAbstractHeader
instance configured with the providedColumn
instances. -
Method Summary
Modifier and TypeMethodDescriptionvoid
boolean
boolean
containsKey
(Object aKey) fromStorageString
(Record<String> aStringRecord) A specialColumn
implementation might provide its own text exchange format for the given objects.fromStorageString
(Row<String> aStringRow) A specialColumn
implementation might provide its own text exchange format for the given objects.fromStorageStringRecord
(Record<String> aStringRecord) A specialColumn
implementation might provide its own text exchange format for the given objects.fromStorageStringRow
(Row<String> aStringRow) A specialColumn
implementation might provide its own text exchange format for the given objects.fromStorageStrings
(Record<String[]> aStringsRecord) A specialColumn
implementation might provide its own text exchange format for the given objects.fromStorageStrings
(Row<String[]> aStringsRow) A specialColumn
implementation might provide its own text exchange format for the given objects.fromStorageStringsRecord
(Record<String[]> aStringsRecord) A specialColumn
implementation might provide its own text exchange format for the given objects.fromStorageStringsRow
(Row<String[]> aStringsRow) A specialColumn
implementation might provide its own text exchange format for the given objects.int
Determines the index of the column with the given key or -1 if there is none such column.keySet()
toPrintable
(Record<? extends T> aRecord) To printable.toPrintable
(Row<? extends T> aRow) To printable.toPrintableRecord
(Row<? extends T> aRow) A specialColumn
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).toPrintableRow
(Record<? extends T> aRecord) To printable row.To record.Record<?>
toRecordIgnoreType
(Row<?> aRow) Similar toHeaderRow.toRecord(Row)
with the difference that conversion is done ignoring the type of theHeaderRow
Column
instances and the according value(s).To row.Row<?>
toRowIgnoreType
(Record<?> aRecord) Similar toHeaderRow.toRow(Record)
with the difference that conversion is done ignoring the type of theHeaderRow
Column
instances and the according value(s).toStorageString
(Record<? extends T> aRecord) To storage string.toStorageString
(Row<? extends T> aRow) To storage string.toStorageStringRecord
(Row<? extends T> aRow) A specialColumn
implementation might provide its own text exchange format for the given objects.toStorageStringRow
(Record<? extends T> aRecord) A specialColumn
implementation might provide its own text exchange format for the given objects.toStorageStrings
(Record<? extends T> aRecord) To storage strings.toStorageStrings
(Row<? extends T> aRow) To storage strings.toStorageStringsRecord
(Row<? extends T> aRow) A specialColumn
implementation might provide its own text exchange format for the given objects.toStorageStringsRow
(Record<? extends T> aRecord) A specialColumn
implementation might provide its own text exchange format for the given objects.toString()
values()
Methods inherited from class java.util.ArrayList
addAll, addAll, clear, clone, contains, ensureCapacity, equals, forEach, get, hashCode, indexOf, isEmpty, iterator, lastIndexOf, listIterator, listIterator, remove, remove, removeAll, removeIf, removeRange, replaceAll, retainAll, set, size, sort, spliterator, subList, toArray, toArray, trimToSize
Methods inherited from class java.util.AbstractCollection
containsAll
Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait
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 org.refcodes.struct.Keys
getOr, use
Methods inherited from interface java.util.List
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
-
Field Details
-
_keys
ALinkedHashSet
is used in order to preserve the order of the elements as contained in theHeader
itself.
-
-
Constructor Details
-
AbstractHeader
public AbstractHeader()Constructs theAbstractHeader
instance. -
AbstractHeader
Constructs theAbstractHeader
instance configured with the providedColumn
instances.- Parameters:
aColumns
- TheColumn
instances to be contained in theAbstractHeader
in the order as passed.
-
-
Method Details
-
containsKey
-
get
-
keySet
-
indexOf
Determines the index of the column with the given key or -1 if there is none such column. -
delete
-
toStorageString
public Record<String> toStorageString(Record<? extends T> aRecord) throws HeaderMismatchException, ColumnMismatchException To storage string.- Specified by:
toStorageString
in interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aRecord
- the record- Returns:
- the record
- Throws:
HeaderMismatchException
- the header mismatch exceptionColumnMismatchException
- the column mismatch exception
-
toStorageString
public Row<String> toStorageString(Row<? extends T> aRow) throws HeaderMismatchException, ColumnMismatchException To storage string.- Specified by:
toStorageString
in interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aRow
- the row- Returns:
- the row
- Throws:
HeaderMismatchException
- the header mismatch exceptionColumnMismatchException
- the column mismatch exception
-
fromStorageString
public Record<T> fromStorageString(Record<String> aStringRecord) throws HeaderMismatchException, ParseException A specialColumn
implementation might provide its own text exchange format for the given objects. This method enables theHeaderRow
to convert aRecord
containing onlyString
objects to aRecord
with the given types and viaHeaderRow.toStorageString(Record)
back to theString
Record
(bijective). This method may use aColumn
instance's methodColumn.fromStorageString(String)
.- Specified by:
fromStorageString
in interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aStringRecord
- theString
Record
to be converted to a typeRecord
.- Returns:
- The type representation of the value.
- Throws:
HeaderMismatchException
- Thrown in case there is a mismatch between the givenColumns
and theRow
, 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 theHeaderRow
.ParseException
- in case parsing the input was not possible
-
fromStorageString
public Row<T> fromStorageString(Row<String> aStringRow) throws HeaderMismatchException, ParseException A specialColumn
implementation might provide its own text exchange format for the given objects. This method enables theHeaderRow
to convert aRow
containing onlyString
objects to aRow
with the given types and viaHeaderRow.toStorageString(Row)
back to theString
Row
(bijective). This method may use aColumn
instance's methodColumn.fromStorageString(String)
.- Specified by:
fromStorageString
in interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aStringRow
- theString
Row
to be converted to a typeRow
.- Returns:
- The type representation of the value.
- Throws:
HeaderMismatchException
- Thrown in case there is a mismatch between the givenHeaderMismatchException
and theRow
, 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 theHeaderRow
.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 interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aRecord
- the record- Returns:
- the record
- Throws:
HeaderMismatchException
- the header mismatch exceptionColumnMismatchException
- the column mismatch exception
-
toStorageStrings
public Row<String[]> toStorageStrings(Row<? extends T> aRow) throws HeaderMismatchException, ColumnMismatchException To storage strings.- Specified by:
toStorageStrings
in interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aRow
- the row- Returns:
- the row
- Throws:
HeaderMismatchException
- the header mismatch exceptionColumnMismatchException
- the column mismatch exception
-
fromStorageStrings
public Row<T> fromStorageStrings(Row<String[]> aStringsRow) throws HeaderMismatchException, ParseException A specialColumn
implementation might provide its own text exchange format for the given objects. This method enables theHeaderRow
to convert aRow
containing onlyString
objects to aRow
with the given types and viaHeaderRow.toStorageStrings(Row)
back to theString
arrayRow
(bijective). This method may use aColumn
instance's methodColumn.fromStorageStrings(String[])
. SupportingString
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 interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aStringsRow
- theString
arrayRow
to be converted to a typeRow
.- Returns:
- The type representation of the value.
- Throws:
HeaderMismatchException
- Thrown in case there is a mismatch between the givenHeaderMismatchException
and theRow
, 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 theHeaderRow
.ParseException
- in case parsing the input was not possible
-
fromStorageStrings
public Record<T> fromStorageStrings(Record<String[]> aStringsRecord) throws HeaderMismatchException, ParseException A specialColumn
implementation might provide its own text exchange format for the given objects. This method enables theHeaderRow
to convert aRecord
containing onlyString
objects to aRecord
with the given types and viaHeaderRow.toStorageStrings(Record)
back to theString
Record
(bijective). This method may use aColumn
instance's methodColumn.fromStorageStrings(String[])
. SupportingString
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 interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aStringsRecord
- theString
arrayRecord
to be converted to a typeRecord
.- Returns:
- The type representation of the value.
- Throws:
HeaderMismatchException
- Thrown in case there is a mismatch between the givenColumns
and theRow
, 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 theHeaderRow
.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 interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aRecord
- the record- Returns:
- the record
- Throws:
HeaderMismatchException
- the header mismatch exceptionColumnMismatchException
- the column mismatch exception
-
toPrintable
public Row<String> toPrintable(Row<? extends T> aRow) throws HeaderMismatchException, ColumnMismatchException To printable.- Specified by:
toPrintable
in interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aRow
- the row- Returns:
- the row
- Throws:
HeaderMismatchException
- the header mismatch exceptionColumnMismatchException
- the column mismatch exception
-
toRow
public Row<T> toRow(Record<? extends T> aRecord) throws HeaderMismatchException, ColumnMismatchException To row.- Specified by:
toRow
in interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aRecord
- the record- Returns:
- the row
- Throws:
HeaderMismatchException
- the header mismatch exceptionColumnMismatchException
- the column mismatch exception
-
toRowIgnoreType
Similar toHeaderRow.toRow(Record)
with the difference that conversion is done ignoring the type of theHeaderRow
Column
instances and the according value(s).- Specified by:
toRowIgnoreType
in interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aRecord
- TheRecord
to use when creating theRow
.- Returns:
- The
Row
according to theColumn
instances of theHeaderRow
. - Throws:
HeaderMismatchException
- Thrown in case there is a mismatch between the givenHeaderMismatchException
and theRow
, 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 theHeaderRow
.
-
toRecord
public Record<T> toRecord(Row<? extends T> aRow) throws HeaderMismatchException, ColumnMismatchException To record.- Specified by:
toRecord
in interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aRow
- the row- Returns:
- the record
- Throws:
HeaderMismatchException
- the header mismatch exceptionColumnMismatchException
- the column mismatch exception
-
toRecordIgnoreType
Similar toHeaderRow.toRecord(Row)
with the difference that conversion is done ignoring the type of theHeaderRow
Column
instances and the according value(s).- Specified by:
toRecordIgnoreType
in interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aRow
- TheRecord
to use when creating theRecord
.- Returns:
- The
Row
according to theColumn
instances of theHeaderRow
. - Throws:
HeaderMismatchException
- Thrown in case there is a mismatch between the givenHeaderMismatchException
and theRow
, 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 theHeaderRow
.
-
fromStorageStringRecord
public Row<T> fromStorageStringRecord(Record<String> aStringRecord) throws HeaderMismatchException, ParseException A specialColumn
implementation might provide its own text exchange format for the given objects. This method enables theHeaderRow
to convert aRecord
containing onlyString
objects to aRow
with the given types and viaHeaderRow.toStorageStringRecord(Row)
back to theString
Record
(bijective). This method may use aColumn
instance's methodColumn.fromStorageString(String)
.- Specified by:
fromStorageStringRecord
in interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aStringRecord
- theString
Record
to be converted to a typeRow
.- Returns:
- The type
Row
representation of theString
Record
. - Throws:
HeaderMismatchException
- Thrown in case there is a mismatch between the givenHeaderMismatchException
and theRow
, 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 theHeaderRow
.ParseException
- in case parsing the input was not possible
-
toStorageStringRecord
public Record<String> toStorageStringRecord(Row<? extends T> aRow) throws HeaderMismatchException, ColumnMismatchException A specialColumn
implementation might provide its own text exchange format for the given objects. This method enables theHeaderRow
to convert aRow
of the given type to aRecord
containing onlyString
values and viaHeaderRow.fromStorageStringRecord(Record)
back to the actualRow
(bijective). This method may use aColumn
instance's methodColumn.toStorageString(Object)
.- Specified by:
toStorageStringRecord
in interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aRow
- TheRow
to be converted to aString
Record
.- Returns:
- The
String
representation of the value. - Throws:
HeaderMismatchException
- Thrown in case there is a mismatch between the givenHeaderMismatchException
and theRow
, 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 theHeaderRow
.ColumnMismatchException
- Thrown in case a value was found in the e.g. in aRow
of the wrong type than specified by aColumn
of theHeaderRow
.
-
fromStorageStringRow
public Record<T> fromStorageStringRow(Row<String> aStringRow) throws HeaderMismatchException, ParseException A specialColumn
implementation might provide its own text exchange format for the given objects. This method enables theHeaderRow
to convert aRow
containing onlyString
objects to aRecord
with the given types and viaHeaderRow.toStorageStringRow(Record)
back to theString
Row
(bijective). This method may use aColumn
instance's methodColumn.fromStorageString(String)
.- Specified by:
fromStorageStringRow
in interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aStringRow
- theString
Row
to be converted to a typeRecord
.- Returns:
- The type representation of the value.
- Throws:
HeaderMismatchException
- Thrown in case there is a mismatch between the givenHeaderMismatchException
and theRow
, 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 theHeaderRow
.ParseException
- in case parsing the input was not possible
-
toStorageStringRow
public Row<String> toStorageStringRow(Record<? extends T> aRecord) throws HeaderMismatchException, ColumnMismatchException A specialColumn
implementation might provide its own text exchange format for the given objects. This method enables theHeaderRow
to convert aRecord
of the given type to aRow
containing onlyString
values and viaHeaderRow.fromStorageStringRecord(Record)
back to the actualRecord
(bijective). This method may use aColumn
instance's methodColumn.toStorageString(Object)
.- Specified by:
toStorageStringRow
in interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aRecord
- TheRow
to be converted to aString
Record
.- Returns:
- The
String
representation of the value. - Throws:
HeaderMismatchException
- Thrown in case there is a mismatch between the givenHeaderMismatchException
and theRow
, 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 theHeaderRow
.ColumnMismatchException
- Thrown in case a value was found in the e.g. in aRecord
of the wrong type than specified by aColumn
of theHeaderRow
.
-
fromStorageStringsRecord
public Row<T> fromStorageStringsRecord(Record<String[]> aStringsRecord) throws HeaderMismatchException, ParseException A specialColumn
implementation might provide its own text exchange format for the given objects. This method enables theHeaderRow
to convert aRecord
containing onlyString
arrays to aRow
with the given types and viaHeaderRow.toStorageStringsRecord(Row)
back to theString
Record
(bijective). This method may use aColumn
instance's methodColumn.fromStorageStrings(String[])
. SupportingString
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 interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aStringsRecord
- theString
Record
to be converted to a typeRow
.- Returns:
- The type
Row
representation of theString
Record
. - Throws:
HeaderMismatchException
- Thrown in case there is a mismatch between the givenHeaderMismatchException
and theRow
, 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 theHeaderRow
.ParseException
- in case parsing the input was not possible
-
toStorageStringsRecord
public Record<String[]> toStorageStringsRecord(Row<? extends T> aRow) throws HeaderMismatchException, ColumnMismatchException A specialColumn
implementation might provide its own text exchange format for the given objects. This method enables theHeaderRow
to convert aRow
of the given type to aRecord
containing onlyString
arrays and viaHeaderRow.fromStorageStringsRecord(Record)
back to the actualRow
(bijective). This method may use aColumn
instance's methodColumn.toStorageStrings(Object)
. SupportingString
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:
toStorageStringsRecord
in interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aRow
- TheRow
to be converted to aString
Record
.- Returns:
- The
String
representation of the value. - Throws:
HeaderMismatchException
- Thrown in case there is a mismatch between the givenHeaderMismatchException
and theRow
, 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 theHeaderRow
.ColumnMismatchException
- Thrown in case a value was found in the e.g. in aRow
of the wrong type than specified by aColumn
of theHeaderRow
.
-
fromStorageStringsRow
public Record<T> fromStorageStringsRow(Row<String[]> aStringsRow) throws HeaderMismatchException, ParseException A specialColumn
implementation might provide its own text exchange format for the given objects. This method enables theHeaderRow
to convert aRow
containing onlyString
arrays to aRecord
with the given types and viaHeaderRow.toStorageStringsRow(Record)
back to theString
Row
(bijective). This method may use aColumn
instance's methodColumn.fromStorageStrings(String[])
. SupportingString
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 interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aStringsRow
- theString
Row
to be converted to a typeRecord
.- Returns:
- The type representation of the value.
- Throws:
HeaderMismatchException
- Thrown in case there is a mismatch between the givenHeaderMismatchException
and theRow
, 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 theHeaderRow
.ParseException
- in case parsing the input was not possible
-
toStorageStringsRow
public Row<String[]> toStorageStringsRow(Record<? extends T> aRecord) throws HeaderMismatchException, ColumnMismatchException A specialColumn
implementation might provide its own text exchange format for the given objects. This method enables theHeaderRow
to convert aRecord
of the given type to aRow
containing onlyString
arrays and viaHeaderRow.fromStorageStringsRecord(Record)
back to the actualRecord
(bijective). This method may use aColumn
instance's methodColumn.toStorageStrings(Object)
. SupportingString
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:
toStorageStringsRow
in interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aRecord
- TheRow
to be converted to aString
Record
.- Returns:
- The
String
representation of the value. - Throws:
HeaderMismatchException
- Thrown in case there is a mismatch between the givenHeaderMismatchException
and theRow
, 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 theHeaderRow
.ColumnMismatchException
- Thrown in case a value was found in the e.g. in aRecord
of the wrong type than specified by aColumn
of theHeaderRow
.
-
toPrintableRow
public Row<String> toPrintableRow(Record<? extends T> aRecord) throws HeaderMismatchException, ColumnMismatchException To printable row.- Specified by:
toPrintableRow
in interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aRecord
- the record- Returns:
- the row
- Throws:
HeaderMismatchException
- the header mismatch exceptionColumnMismatchException
- the column mismatch exception
-
toPrintableRecord
public Record<String> toPrintableRecord(Row<? extends T> aRow) throws HeaderMismatchException, ColumnMismatchException A specialColumn
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 theHeaderRow
to convert aRow
of the given type to a human readable textRecord
. The human readable text, in comparison to the methodHeaderRow.toStorageString(Row)
(orHeaderRow.toRecordIgnoreType(Row)
) is not intended to be converted back to the actual value (not bijective). This method may use aColumn
instance's methodColumn.toPrintable(Object)
; it also might enrich the output of theColumn.toPrintable(Object)
with device specific additional data such as ANSI Escape-Codes and with information regarding theRow
as a whole and not just be regarding a single value.- Specified by:
toPrintableRecord
in interfaceHeaderRow<T,
C extends Column<? extends T>> - Parameters:
aRow
- theRow
to be converted to a human readable textRecord
.- Returns:
- The human readable
Record
representation of theRow
. - Throws:
HeaderMismatchException
- Thrown in case there is a mismatch between the givenHeaderMismatchException
and theRow
, 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 theHeaderRow
.ColumnMismatchException
- Thrown in case a value was found in the e.g. in aRow
of the wrong type than specified by aColumn
of theHeaderRow
.
-
add
-
add
-
values
-
toString
- Overrides:
toString
in classAbstractCollection<C extends Column<? extends T>>
-