Uses of Interface
org.refcodes.tabular.Record

Packages that use Record

Package	Description
org.refcodes.tabular	The tabular package provides a frame to handle tables of data, often occurring when logging or when working with CSV files.
org.refcodes.tabular.impls
org.refcodes.tabular.mixins
org.refcodes.tabular.utils

Uses of Record in org.refcodes.tabular

Methods in org.refcodes.tabular that return Record

Modifier and Type	Method and Description
Record<T>	Header.fromStorageString(Record<String> aStringRecord) A special Column implementation might provide its own text exchange format for the given objects.
Record<T>	Header.fromStorageStringRow(Row<String> aStringRow) A special Column implementation might provide its own text exchange format for the given objects.
Record<T>	Header.fromStorageStrings(Record<String[]> aStringsRecord) A special Column implementation might provide its own text exchange format for the given objects.
Record<T>	Header.fromStorageStringsRow(Row<String[]> aStringsRow) A special Column implementation might provide its own text exchange format for the given objects.
Record<String>	Header.toPrintable(Record<? extends T> aRecord) A special Column implementation might provide its own printable format of the given objects; for example a human readable text representation of the value (or in very specialized cases even enriched with ANSI escape codes).
Record<String>	Header.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).
Record<T>	Header.toRecord(Row<? extends T> aRow) Creates a Record of the Row with the values in the order of the Header.
Record<?>	Header.toRecordIgnoreType(Row<?> aRow) Similar to Header.toRecord(Row) with the difference that conversion is done ignoring the type of the Header Column instances and the according value(s).
Record<String>	Header.toStorageString(Record<? extends T> aRecord) A special Column implementation might provide its own text exchange format for the given objects.
Record<String>	Header.toStorageStringRecord(Row<? extends T> aRow) A special Column implementation might provide its own text exchange format for the given objects.
Record<String[]>	Header.toStorageStrings(Record<? extends T> aRecord) A special Column implementation might provide its own text exchange format for the given objects.
Record<String[]>	Header.toStorageStringsRecord(Row<? extends T> aRow) A special Column implementation might provide its own text exchange format for the given objects.

Methods in org.refcodes.tabular with parameters of type Record

Modifier and Type	Method and Description
boolean	Column.contains(Record<?> aRecord) Tests whether the 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.
Record<T>	Header.fromStorageString(Record<String> aStringRecord) A special Column implementation might provide its own text exchange format for the given objects.
Row<T>	Header.fromStorageStringRecord(Record<String> aStringRecord) A special Column implementation might provide its own text exchange format for the given objects.
Record<T>	Header.fromStorageStrings(Record<String[]> aStringsRecord) A special Column implementation might provide its own text exchange format for the given objects.
Row<T>	Header.fromStorageStringsRecord(Record<String[]> aStringsRecord) A special Column implementation might provide its own text exchange format for the given objects.
T	Column.get(Record<?> aRecord) Retrieves a type correct value from the Record identified by the Column instance's key.
T	Column.remove(Record<?> aRecord) Removes an entry (key and value pair) from the provided Record matching the key and the type of the Column.
Record<String>	Header.toPrintable(Record<? extends T> aRecord) A special Column implementation might provide its own printable format of the given objects; for example a human readable text representation of the value (or in very specialized cases even enriched with ANSI escape codes).
Row<String>	Header.toPrintableRow(Record<? extends T> aRecord) A special Column implementation might provide its own printable format of the given objects; for example a human readable text representation of the value (or in very specialized cases even enriched with ANSI escape codes).
Row<T>	Header.toRow(Record<? extends T> aRecord) Creates a Row of the Record with the values in the order of the Header.
Row<?>	Header.toRowIgnoreType(Record<?> aRecord) Similar to Header.toRow(Record) with the difference that conversion is done ignoring the type of the Header Column instances and the according value(s).
Record<String>	Header.toStorageString(Record<? extends T> aRecord) A special Column implementation might provide its own text exchange format for the given objects.
Row<String>	Header.toStorageStringRow(Record<? extends T> aRecord) A special Column implementation might provide its own text exchange format for the given objects.
Record<String[]>	Header.toStorageStrings(Record<? extends T> aRecord) A special Column implementation might provide its own text exchange format for the given objects.
Row<String[]>	Header.toStorageStringsRow(Record<? extends T> aRecord) A special Column implementation might provide its own text exchange format for the given objects.

Uses of Record in org.refcodes.tabular.impls

Classes in org.refcodes.tabular.impls that implement Record

Modifier and Type	Class and Description
class	RecordImpl<T> Implementation of the Record interface being Cloneable.

Methods in org.refcodes.tabular.impls that return Record

Modifier and Type	Method and Description
Record<T>	HeaderImpl.fromStorageString(Record<String> aStringRecord) A special Column implementation might provide its own text exchange format for the given objects.
Record<T>	HeaderImpl.fromStorageStringRow(Row<String> aStringRow) A special Column implementation might provide its own text exchange format for the given objects.
Record<T>	HeaderImpl.fromStorageStrings(Record<String[]> aStringsRecord) A special Column implementation might provide its own text exchange format for the given objects.
Record<T>	HeaderImpl.fromStorageStringsRow(Row<String[]> aStringsRow) A special Column implementation might provide its own text exchange format for the given objects.
Record<? extends T>	RecordsImpl.next()
Record<T>	CsvInputStreamRecordsImpl.next()
Record<? extends T>	CompositeRecordsImpl.next()
Record<String>	HeaderImpl.toPrintable(Record<? extends T> aRecord) A special Column implementation might provide its own printable format of the given objects; for example a human readable text representation of the value (or in very specialized cases even enriched with ANSI escape codes).
Record<String>	HeaderImpl.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).
Record<T>	HeaderImpl.toRecord(Row<? extends T> aRow) Creates a Record of the Row with the values in the order of the Header.
Record<?>	HeaderImpl.toRecordIgnoreType(Row<?> aRow) Similar to Header.toRecord(Row) with the difference that conversion is done ignoring the type of the Header Column instances and the according value(s).
Record<String>	HeaderImpl.toStorageString(Record<? extends T> aRecord) A special Column implementation might provide its own text exchange format for the given objects.
Record<String>	HeaderImpl.toStorageStringRecord(Row<? extends T> aRow) A special Column implementation might provide its own text exchange format for the given objects.
Record<String[]>	HeaderImpl.toStorageStrings(Record<? extends T> aRecord) A special Column implementation might provide its own text exchange format for the given objects.
Record<String[]>	HeaderImpl.toStorageStringsRecord(Row<? extends T> aRow) A special Column implementation might provide its own text exchange format for the given objects.

Methods in org.refcodes.tabular.impls with parameters of type Record

Modifier and Type	Method and Description
boolean	AbstractColumn.contains(Record<?> aRecord) Tests whether the 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.
Record<T>	HeaderImpl.fromStorageString(Record<String> aStringRecord) A special Column implementation might provide its own text exchange format for the given objects.
Row<T>	HeaderImpl.fromStorageStringRecord(Record<String> aStringRecord) A special Column implementation might provide its own text exchange format for the given objects.
Record<T>	HeaderImpl.fromStorageStrings(Record<String[]> aStringsRecord) A special Column implementation might provide its own text exchange format for the given objects.
Row<T>	HeaderImpl.fromStorageStringsRecord(Record<String[]> aStringsRecord) A special Column implementation might provide its own text exchange format for the given objects.
T	AbstractColumn.get(Record<?> aRecord) Retrieves a type correct value from the Record identified by the Column instance's key.
T	AbstractColumn.remove(Record<?> aRecord) Removes an entry (key and value pair) from the provided Record matching the key and the type of the Column.
Record<String>	HeaderImpl.toPrintable(Record<? extends T> aRecord) A special Column implementation might provide its own printable format of the given objects; for example a human readable text representation of the value (or in very specialized cases even enriched with ANSI escape codes).
Row<String>	HeaderImpl.toPrintableRow(Record<? extends T> aRecord) A special Column implementation might provide its own printable format of the given objects; for example a human readable text representation of the value (or in very specialized cases even enriched with ANSI escape codes).
Row<T>	HeaderImpl.toRow(Record<? extends T> aRecord) Creates a Row of the Record with the values in the order of the Header.
Row<?>	HeaderImpl.toRowIgnoreType(Record<?> aRecord) Similar to Header.toRow(Record) with the difference that conversion is done ignoring the type of the Header Column instances and the according value(s).
Record<String>	HeaderImpl.toStorageString(Record<? extends T> aRecord) A special Column implementation might provide its own text exchange format for the given objects.
Row<String>	HeaderImpl.toStorageStringRow(Record<? extends T> aRecord) A special Column implementation might provide its own text exchange format for the given objects.
Record<String[]>	HeaderImpl.toStorageStrings(Record<? extends T> aRecord) A special Column implementation might provide its own text exchange format for the given objects.
Row<String[]>	HeaderImpl.toStorageStringsRow(Record<? extends T> aRecord) A special Column implementation might provide its own text exchange format for the given objects.

Constructors in org.refcodes.tabular.impls with parameters of type Record

Constructor and Description
RecordsImpl(Record<? extends T>... aRecords) Constructs the RecordsImpl instance configured with the provided Record instances.

Constructor parameters in org.refcodes.tabular.impls with type arguments of type Record

Constructor and Description
RecordsImpl(Collection<Record<? extends T>> aRecords) Constructs the RecordsImpl instance configured with the provided Record instances.

Uses of Record in org.refcodes.tabular.mixins

Methods in org.refcodes.tabular.mixins that return Record

Modifier and Type	Method and Description
Record<T>	RecordAccessor.getRecord() Retrieves the Record property.

Methods in org.refcodes.tabular.mixins with parameters of type Record

Modifier and Type	Method and Description
void	RecordAccessor.RecordMutator.setRecord(Record<T> aDataRecord) Sets the Record property.

Uses of Record in org.refcodes.tabular.utils

Methods in org.refcodes.tabular.utils that return Record

Modifier and Type	Method and Description
static <T> Record<T>	TabularUtility.toIntersection(Record<T> aRecord, Header<?> aHeader) Returns a Record just containing the keys as defined in the Header and found in the provided Record. ------------------------------------------------------------------------- TODO: Think about moving this method to the Header
static Record<?>	TabularUtility.toPurged(Record<?> aRecord) The given Record is taken and only all non null values are taken for the returned Record.
static <T> Record<T>	TabularUtility.toSubset(Record<T> aRecord, Header<?> aHeader) Returns a Record just containing the keys as defined in the Header; keys not found in the provided Record are ignored. ------------------------------------------------------------------------- TODO: Think about moving this method to the Header

Methods in org.refcodes.tabular.utils with parameters of type Record

Modifier and Type	Method and Description
static boolean	TabularUtility.isEqualWith(Record<?> aRecord, Header<?> aEquivalsWith) Tests whether the given potential equal set of Header is matching the Record's elements in terms of matching the same relevant attributes of the columns with the elements in the Record.
static boolean	TabularUtility.isSubsetOf(Record<?> aRecord, Header<?> aSupersetOf) Tests whether the given potential subset of Header is matching the Record's elements in terms of matching the same relevant attributes of the Column instances with the elements in the Record.
static boolean	TabularUtility.isSupersetOf(Record<?> aRecord, Header<?> aSubsetOf) Tests whether the Record's elements is matching the given potential superset of Header in terms of matching the same relevant attributes of the columns with the elements in the Record.
static <T> Record<T>	TabularUtility.toIntersection(Record<T> aRecord, Header<?> aHeader) Returns a Record just containing the keys as defined in the Header and found in the provided Record. ------------------------------------------------------------------------- TODO: Think about moving this method to the Header
static Record<?>	TabularUtility.toPurged(Record<?> aRecord) The given Record is taken and only all non null values are taken for the returned Record.
static String	TabularUtility.toSeparatedValues(Record<?> aRecord) Returns a separated values representation of the implementing collection by separating each item with the default separator DelimeterConsts.CSV_DELIMETER.
static String	TabularUtility.toSeparatedValues(Record<?> aRecord, char aDelimiter) Returns a separated values representation of the implementing collection by separating each item with the given separator.
static String	TabularUtility.toString(Record<?> aRecord) Creates the string representation from from the given record.
static String	TabularUtility.toString(Record<?> aRecord, char aSeparator, SimpleDateFormat[] aDateFormats) Creates the string representation from from the given record.
static <T> Record<T>	TabularUtility.toSubset(Record<T> aRecord, Header<?> aHeader) Returns a Record just containing the keys as defined in the Header; keys not found in the provided Record are ignored. ------------------------------------------------------------------------- TODO: Think about moving this method to the Header