T - The type managed by the column.Cloneable, org.refcodes.mixin.KeyAccessor<T>, org.refcodes.mixin.TypeAccessor<T>, Column<T>ColumnImpl, DateColumnImpl, ExceptionColumnImpl, IntegerColumnImpl, StringColumnImpl, StringsColumnImplpublic abstract class AbstractColumn<T> extends Object implements Column<T>, Cloneable
AbstractColumn is the default implementation for the
Column interface. It implements amongst others the
toStorageString(Object) and fromStorageString(String)
methods leaving the developer to implement in sub-classes only the two
methods Column.toStorageStrings(Object) as well as
Column.fromStorageStrings(String[]) which are to do the actual conversions.
Special care is taken when the type T is an array type:
The method toStorageString(Object) returns a String with
separated values (in terms of CSV) in case the type T is an array type. The
delimiter of the values in this String then is the
Delimiter.ARRAY character as we use the Delimiter.CSV when
embedding the returned String in a CSV list (file).
The method fromStorageString(String) interprets the passed
String as separated values (in terms of CSV) in case the type T is an
array type. It creates a String array from the String value;
the delimiter of the values in the String used is the
Delimiter.ARRAY character as we use the Delimiter.CSV when
parsing a String in a CSV list (file).
org.refcodes.mixin.KeyAccessor.KeyBuilder<K extends Object,B extends org.refcodes.mixin.KeyAccessor.KeyBuilder<K,B>>, org.refcodes.mixin.KeyAccessor.KeyMutator<K extends Object>, org.refcodes.mixin.KeyAccessor.KeyProperty<K extends Object>| Constructor | Description |
|---|---|
AbstractColumn(String aKey,
Class<T> aType) |
Constructs a column.
|
| Modifier and Type | Method | Description |
|---|---|---|
Object |
clone() |
|
boolean |
contains(Record<?> aRecord) |
|
T |
fromStorageString(String aStringValue) |
A
Column implementation can provide its own text exchange format
for the given objects. |
T |
get(Record<?> aRecord) |
|
String |
getKey() |
|
Class<T> |
getType() |
|
T |
remove(Record<?> aRecord) |
|
String |
toPrintable(T aValue) |
A
Column implementation can 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). |
String |
toStorageString(T aValue) |
A
Column implementation can provide its own text exchange format
for the given objects. |
fromStorageStrings, toStorageStringspublic String toStorageString(T aValue)
Column implementation can provide its own text exchange format
for the given objects. This method enables the Column to convert
a value of the given type to a String and via
Column.fromStorageString(String) back to the value (bijective).
This method supports data sinks (such as relational databases) which
allow only a single value in a row's entry: In case T is an array type,
then the storage String representation of the elements in that
array are represented by a single returned String.
In case a data sink (such as Amazon's SimpleDb) is to be addressed which
provides dedicated support for multiple values in one row's entry, then
the method Column.toStorageStrings(Object) may be used instead.toStorageString in interface Column<T>aValue - the element to be converted to a String.String representation of the value.public T fromStorageString(String aStringValue) throws ParseException
Column implementation can provide its own text exchange format
for the given objects. This method enables the Column to convert
a String value to a value of the given type and via
Column.toStorageString(Object) back to the String (bijective).
This method supports data sinks (such as relational databases) which
allow only a single value in a row's entry: In case T is an array type,
then the storage String representation of the elements in that
array are represented by the single passed String.
In case a data sink (such as Amazon's SimpleDb) is to be addressed which
provides dedicated support for multiple values in one row's entry, then
the method Column.fromStorageStrings(String[]) may be used instead.fromStorageString in interface Column<T>aStringValue - The value to be converted to a type instance.ParseException - in case parsing the String was not
possiblepublic String toPrintable(T aValue)
Column implementation can 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 Column to convert a value of the
given type to a human readable text. The human readable text, in
comparison to the method Object.toString() (or
Column.toStorageString(Object)) is not intended to be converted back to
the actual value (not bijective).
This method may be used a Header instance's method
HeaderTemplate.toPrintable(Record).toPrintable in interface Column<T>aValue - the element to be converted to a human readable text.public boolean contains(Record<?> aRecord)
Record contains a value identified by the
Column instance's key and where the value's type is assignable to
the Column instance's type. Only if them both criteria match,
then true is returned. False is returned if there is no such value or the
value is not assignable to the Column instance's type.contains in interface Column<T>aRecord - The Record which to test if there is a value
associated to the Column instance's key and if it can be
casted to the Column instance's type.Record contains a value identified by
the Column instance's key and where the value's type is
assignable to the Column instance's type.public T get(Record<?> aRecord) throws ColumnMismatchException
ColumnRecord identified by the
Column instance's key. In case the type of the Column
instance does not match the value's type associated with the
Column instance's key, then a ColumnMismatchException is
thrown.get in interface Column<T>aRecord - The Record from which to retrieve the value
associated to the Column instances key.Record associated to the
Column instances key.ColumnMismatchException - in case the value in the Record
associated with the Column instance's key does not fit
the Column instance's type.public T remove(Record<?> aRecord) throws ColumnMismatchException
ColumnRecord
matching the key and the type of the Column.remove in interface Column<T>aRecord - The Record from which to remove the related entry.Column instance's key or
null if there was none such value found.ColumnMismatchException - in case the value in the Record
associated with the Column instance's key does not fit
the Column instance's type.public Class<T> getType()
getType in interface org.refcodes.mixin.TypeAccessor<T>public Object clone() throws CloneNotSupportedException
clone in class ObjectCloneNotSupportedExceptionCopyright © 2018. All rights reserved.