Table

java.lang.Object
- uk.ac.ed.epcc.webapp.content.Table<C,R>

Type Parameters:

C -

R -
```
public class Table<C,R>
extends java.lang.Object
```
A generic representation of a table that we can easily change into html/xml or other text. Table can be sparse and is essentially a Hashtable of Hashtables. Entries can be any type of object The table class maintains a list of keys determining the order which rows/cols are presented. by default this reflects the order the elements were added to the table. but there are special functions for handling subclasses of Number (summing cols/rows etc). Summary lines like totals can be inserted as Strings to prevent them being inluded in futher summation etc.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`Table.Col` A column of the table
`static interface`	`Table.Formatter<C,R>` Formatter; converts table entries when printing.
`static class`	`Table.NumberFormatGenerator`
`static class`	`Table.Sorter<C>` Implements a sort of rows based on the natural order of the various table cols.
`static class`	`Table.TransformFormatter<C,R>` Adapter to convert a Transform into a Formatter

Constructor Summary

Constructors
Constructor and Description

Table()

Table(Table<C,R> t)
Construct a duplicate of the supplied table

Constructors
Constructor and Description
`Table()`
`Table(Table<C,R> t)` Construct a duplicate of the supplied table

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`add(Table<C,R> t)` Add contents of existing table
`void`	`addAttribute(C col, R row, java.lang.String name, java.lang.String value)` add attribute to a single cell.
`void`	`addCategoryTotals(C sum_col, C cat_Col, Transform cat_to_key)` Generate a series of column sums grouped into categories based on the values of a different column.
`void`	`addCategoryTotals(C sum_col, C cat_Col, Transform cat_to_key, C label_col, java.lang.Boolean highlight)` Generate a series of column sums grouped into categories based on the values of a different column.
`void`	`addCategoryTotalToCol(C sum_col, C cat_Col)`
`void`	`addCategoryTotalToCol(C sum_col, C cat_Col, java.util.Map selection)` Generate sums of a column based on categories provided by a different column.
`void`	`addColAttribute(C col, java.lang.String name, java.lang.String value)` Add attribute to all cells in col
`<X> void`	`addColumnAsRow(R row_key, X col_key, Table<X,C> t)` Take a column from one table and add it as a row to this one.
`void`	`addMap(C col_name, java.util.Map<R,?> data)` Add a `Map` of data into a column If the data is a Number it is accumulated.
`void`	`addMap(C col_name, java.util.Map<R,R> row_mapping, java.util.Map<R,?> data)` Add a `Map` of data into a column If the data is a Number it is accumulated.
`java.lang.Object`	`addNumber(C col_key, R row_key, java.lang.Number value)`
`void`	`addPercentCol(C old_name, C new_name)` Add a column containing the percentage of the values from an existing column against the total of that column
`void`	`addPercentCol(C old_name, C new_name, java.lang.Double sum)` add a column giving the percentage of a columns values against a specified total.
`void`	`addPercentCol(C old_name, C new_name, java.lang.Double sum, java.text.NumberFormat nf)`
`void`	`addPercentCol(C old_name, C new_name, java.text.NumberFormat nf)` Add a column containing the percentage of the values from an existing column against the total of that column
`void`	`addRow(R key)`
`void`	`addRow(R key, java.util.Map<C,java.lang.Object> data)` Add a Map as a table row using the map keys to set the columns
`void`	`addRows(Table<C,R> t)` Add rows (including formatting) from a table.
`<X> void`	`addTable(C key_col, Table<C,X> donor)` Add contents from donor table taking the keys to use from a Column in the donor table.
`<X> void`	`addTable(Transform key_transform, Table<C,X> donor)` Add contents from donor table transforming the keys
`void`	`addToGroup(C group, C col)`
`java.lang.Double`	`addTotalToCol(C col_name, R key)` Add a totals entry to column This is a noop if the specified col does not exist
`void`	`addTotalToCol(int col_index, R key)` Add a totals entry to a column
`void`	`colOperation(C result_col, Operator op, C left_col, C right_col)`
`java.util.Collection<C>`	`cols()` Deprecated.
`boolean`	`containsCol(C col_name)` Do we have a col of this name
`java.lang.Object`	`get(C col_key, R row_key)`
`java.util.Map<java.lang.String,java.lang.String>`	`getAttributes(C col_key, R row_key)`
`Table.Col`	`getCol(C col_key)` Find or create a col by key
`Table.Formatter`	`getColFormat(C col_key)`
`java.util.List<C>`	`getCols()` Get a copy of the list of col keys.
`java.util.List<C>`	`getColumNames()`
`java.lang.Iterable<C>`	`getColumnGroup(C name)`
`java.lang.Iterable<C>`	`getColumnGroups()` get all the defined Column Groups
`java.util.Hashtable<java.lang.String,java.lang.Number>`	`getHashtable(C col_key)`
`java.util.Hashtable<java.lang.String,java.lang.Number>`	`getHashtable(C col_key, C label_key)` get a hashtable of the contents of one Col keyed by the contents of another
`boolean`	`getHighlight(R row_key)` should we highlight this row.
`java.lang.String`	`getId()`
`java.lang.String`	`getKeyName()`
`java.lang.Object`	`getKeyText(R key)` Convert a row key into printable text
`java.lang.Number`	`getNumber(C col_key, R row_key)`
`java.util.List<R>`	`getRows()` Get a copy of the list of row keys.
`java.lang.String`	`getString()` get the table as a pure String
`java.lang.String`	`getText(C col_key, R row_key)`
`java.lang.String`	`getText(java.text.NumberFormat nf, C col_key, R row_key)`
`boolean`	`getWarning(R row_key)` should we mark this row with warning highlight.
`boolean`	`hasCol(java.lang.String string)`
`boolean`	`hasColFormat(C col_name)`
`boolean`	`hasColumnGroup(C name)`
`boolean`	`hasData()`
`boolean`	`hasRow(R key)`
`java.lang.Object`	`increment(C col_key, R row_key, int value)` increment a integer entry
`boolean`	`isPrintHeadings()`
`int`	`nCols()`
`int`	`nRows()`
`void`	`packAllColumnGroups()` For all column groups.
`void`	`packColumnGroup(C name)` place all members of a column group after the first member of the group.
`boolean`	`printKeys()` Should the table keys be printed as part of the table.
`java.lang.Object`	`put(C col_key, R row_key, java.lang.Object value)`
`java.lang.Object`	`putAfter(C col_key, R row_key, R after, java.lang.Object value)`
`void`	`removeCol(C key)` remove a col from display data is retained and will return if key is replaced.
`void`	`removeRow(R key)`
`void`	`rowOperation(R result_row, Operator op, R left_row, R right_row)`
`java.util.Collection<R>`	`rows()` Deprecated.
`void`	`rowToString(R row_name)` convert all elements in a row to strings so they don't count against additional col totals
`void`	`setCategoryRow(C target_col, C cat_Col, Transform cat_to_key, Transform cat_to_val)`
`void`	`setCol(C key, int ind)` Set col to specified position
`void`	`setColAfter(C first, C after)` set one col to follow another
`Table.Formatter<C,R>`	`setColFormat(C col_name, Table.Formatter<C,R> t)`
`Table.Formatter`	`setColFormat(C col_name, Transform t)`
`void`	`setColLast(C key)` set col to last position
`void`	`setColName(C key, java.lang.String name)`
`void`	`setColumns(java.util.List<C> v)`
`void`	`setFormat(Table.Formatter<C,R> t)` Set a printing format for all columns
`void`	`setFormat(Transform t)`
`void`	`setHighlight(R row_key, boolean value)` mark a row to be highlighted
`void`	`setId(java.lang.String id)`
`void`	`setKeyName(java.lang.String keyName)` Set the column name for the keys column this also causes the key column to be printed
`void`	`setKeyTransform(Transform t)` Set a Transform used to print the keys.
`void`	`setPrintHeadings(boolean printHeadings)`
`void`	`setRow(R key, int ind)` set row to specified position
`void`	`setRowAfter(R key, R after)`
`void`	`setRowLast(R key)` set row to last position
`void`	`setTypeDebug(boolean flag)` add Java type information to output for debugging purposes.
`void`	`setWarning(R row_key, boolean value)` mark a row to be highlighted
`void`	`sortCols(java.util.Comparator c)` Sort columns according to a specified comparator
`void`	`sortRows()` sort rows using natural ordering of row keys
`void`	`sortRows(C[] keys, boolean reverse)` Sort Rows by the natural ordering of a set of column values.
`void`	`sortRows(java.util.Comparator c)` Sort rows according to row keys using a specified comparator
`double`	`sumCol(C key)` sum the numerical values in a column
`<T> void`	`thresholdRows(C col, MatchCondition cond, T value)` Remove all rows based on values in a column row is removed if *col-value Condition* value = true**
`java.lang.String`	`toString()`
`void`	`transformCol(C col_name, Transform t)` Apply a `Transform` to a column selected by name.
`void`	`transformCol(int col_index, Transform t)` apply a `Transform` to a column selected by index.
`void`	`transformKeys(C dest, Transform t)` Create a new column based on a `Transform` applied to the current row keys.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail
- Table
```
public Table()
```
- Table
```
public Table(Table<C,R> t)
```
  Construct a duplicate of the supplied table
  
  Parameters:
  
  t -

Method Detail

addColumnAsRow
```
public <X> void addColumnAsRow(R row_key,
                               X col_key,
                               Table<X,C> t)
```
Take a column from one table and add it as a row to this one. This is useful for turning a single column summary table for one object into an index table showing many objects.

Parameters:

row_key - row to add

col_key - remote column to take

t -

add
```
public void add(Table<C,R> t)
```
Add contents of existing table

Parameters:

t -

addTable
```
public <X> void addTable(Transform key_transform,
                         Table<C,X> donor)
```
Add contents from donor table transforming the keys

Parameters:

key_transform - Transform to map donor rows to local rows

table -

addTable
```
public <X> void addTable(C key_col,
                         Table<C,X> donor)
```
Add contents from donor table taking the keys to use from a Column in the donor table. This can be used to create a table which merges rows based on the value in a col. The key_col is not imported from the donor.

Parameters:

key_col - column in donor table containing row key values to use

table -

addRows
```
public void addRows(Table<C,R> t)
```
Add rows (including formatting) from a table.

Parameters:

t -

addAttribute

public void addAttribute(C col,
                         R row,
                         java.lang.String name,
                         java.lang.String value)

add attribute to a single cell.

Parameters:: col -; row -; name -; value -

addCategoryTotals
```
public void addCategoryTotals(C sum_col,
                              C cat_Col,
                              Transform cat_to_key)
```
Generate a series of column sums grouped into categories based on the values of a different column.

Parameters:

sum_col -

cat_Col -

cat_to_key - Transform to convert the category value into the key

addCategoryTotals
```
public void addCategoryTotals(C sum_col,
                              C cat_Col,
                              Transform cat_to_key,
                              C label_col,
                              java.lang.Boolean highlight)
```
Generate a series of column sums grouped into categories based on the values of a different column. The cat_to_key Transform is used to generate a key for the Sum col from the category value. If the label_col value is non null the key value is also inserted into this col (to generate sum labels for tables where the key values are not shown)

Parameters:

sum_col -

cat_Col -

cat_to_key -

label_col -

highlight -

setCategoryRow

public void setCategoryRow(C target_col,
                           C cat_Col,
                           Transform cat_to_key,
                           Transform cat_to_val)

addCategoryTotalToCol

public void addCategoryTotalToCol(C sum_col,
                                  C cat_Col)

addCategoryTotalToCol
```
public void addCategoryTotalToCol(C sum_col,
                                  C cat_Col,
                                  java.util.Map selection)
```
Generate sums of a column based on categories provided by a different column.

Parameters:

sum_col - name of col to be summed

cat_Col - name of column specifying categories

selection - map specifying categories to sum. keyed by the category and defining the keys to use for the sums

addColAttribute

public void addColAttribute(C col,
                            java.lang.String name,
                            java.lang.String value)

Add attribute to all cells in col

Parameters:: col -; name -; value -

addMap
```
public void addMap(C col_name,
                   java.util.Map<R,?> data)
```
Add a Map of data into a column If the data is a Number it is accumulated.

Parameters:

col_name -

data - Map of data

addMap
```
public void addMap(C col_name,
                   java.util.Map<R,R> row_mapping,
                   java.util.Map<R,?> data)
```
Add a Map of data into a column If the data is a Number it is accumulated. Row mapping translate the data keys into table row-keys if no mapping exists the data-key is used unchanged.

Parameters:

col_name -

row_mapping - (optional row translations).

data - Map of data

addNumber

public java.lang.Object addNumber(C col_key,
                                  R row_key,
                                  java.lang.Number value)

addPercentCol
```
public void addPercentCol(C old_name,
                          C new_name)
```
Add a column containing the percentage of the values from an existing column against the total of that column

Parameters:

old_name -

new_name -

addPercentCol

public void addPercentCol(C old_name,
                          C new_name,
                          java.lang.Double sum)

add a column giving the percentage of a columns values against a specified total.

Parameters:: old_name -; new_name -; sum -

addPercentCol

public void addPercentCol(C old_name,
                          C new_name,
                          java.lang.Double sum,
                          java.text.NumberFormat nf)

addPercentCol
```
public void addPercentCol(C old_name,
                          C new_name,
                          java.text.NumberFormat nf)
```
Add a column containing the percentage of the values from an existing column against the total of that column

Parameters:

old_name -

new_name -

nf - NumberFormat to format col

addRow
```
public void addRow(R key)
```

addRow
```
public void addRow(R key,
                   java.util.Map<C,java.lang.Object> data)
```
Add a Map as a table row using the map keys to set the columns

Parameters:

key - Row key

data - Row data

addTotalToCol
```
public java.lang.Double addTotalToCol(C col_name,
                                      R key)
```
Add a totals entry to column This is a noop if the specified col does not exist

Parameters:

col_name - String key of column to modify

key - Object key to use for total

Returns:

total calculated or null if no column.

addTotalToCol

public void addTotalToCol(int col_index,
                          R key)

Add a totals entry to a column

Parameters:: col_index - int index of col; key - key to use for Total

colOperation

public void colOperation(C result_col,
                         Operator op,
                         C left_col,
                         C right_col)

rowOperation

public void rowOperation(R result_row,
                         Operator op,
                         R left_row,
                         R right_row)

cols

@Deprecated
public java.util.Collection<C> cols()

Deprecated.

containsCol
```
public boolean containsCol(C col_name)
```
Do we have a col of this name

Parameters:

col_name -

Returns:

boolean

get

public java.lang.Object get(C col_key,
                            R row_key)

getAttributes

public java.util.Map<java.lang.String,java.lang.String> getAttributes(C col_key,
                                                                      R row_key)

getCol
```
public Table.Col getCol(C col_key)
```
Find or create a col by key

Parameters:

col_key -

Returns:

Col

getColFormat

public Table.Formatter getColFormat(C col_key)

getCols
```
public java.util.List<C> getCols()
```
Get a copy of the list of col keys.

Returns:

List of col keys

getColumNames

public java.util.List<C> getColumNames()

getHashtable

public java.util.Hashtable<java.lang.String,java.lang.Number> getHashtable(C col_key)
                                                                    throws InvalidArgument

Throws:: InvalidArgument

getHashtable

public java.util.Hashtable<java.lang.String,java.lang.Number> getHashtable(C col_key,
                                                                           C label_key)
                                                                    throws InvalidArgument

get a hashtable of the contents of one Col keyed by the contents of another

Parameters:: col_key -; label_key -
Returns:: hashtable
Throws:: InvalidArgument

getHighlight
```
public boolean getHighlight(R row_key)
```
should we highlight this row.

Parameters:

row_key -

Returns:

boolean

getKeyName
```
public java.lang.String getKeyName()
```

getKeyText
```
public java.lang.Object getKeyText(R key)
```
Convert a row key into printable text

Parameters:

key -

Returns:

String

getNumber

public java.lang.Number getNumber(C col_key,
                                  R row_key)

getRows
```
public java.util.List<R> getRows()
```
Get a copy of the list of row keys.

Returns:

list of row keys

getString
```
public java.lang.String getString()
```
get the table as a pure String

Returns:

String

getText

public java.lang.String getText(C col_key,
                                R row_key)

getText

public java.lang.String getText(java.text.NumberFormat nf,
                                C col_key,
                                R row_key)

getWarning
```
public boolean getWarning(R row_key)
```
should we mark this row with warning highlight.

Parameters:

row_key -

Returns:

boolean

hasCol

public boolean hasCol(java.lang.String string)

hasColFormat

public boolean hasColFormat(C col_name)

hasData
```
public boolean hasData()
```

hasRow
```
public boolean hasRow(R key)
```

increment

public java.lang.Object increment(C col_key,
                                  R row_key,
                                  int value)

increment a integer entry

Parameters:: col_key -; row_key -; value -
Returns:: previous entry

isPrintHeadings
```
public boolean isPrintHeadings()
```

nCols
```
public int nCols()
```

nRows
```
public int nRows()
```

printKeys
```
public boolean printKeys()
```
Should the table keys be printed as part of the table. Ususally defaults to whether a keyname has been specifed

Returns:

boolean

put

public java.lang.Object put(C col_key,
                            R row_key,
                            java.lang.Object value)

putAfter

public java.lang.Object putAfter(C col_key,
                                 R row_key,
                                 R after,
                                 java.lang.Object value)

removeCol
```
public void removeCol(C key)
```
remove a col from display data is retained and will return if key is replaced.

Parameters:

key -

removeRow
```
public void removeRow(R key)
```

rows

@Deprecated
public java.util.Collection<R> rows()

Deprecated.

rowToString
```
public void rowToString(R row_name)
```
convert all elements in a row to strings so they don't count against additional col totals

Parameters:

row_name -

setCol

public void setCol(C key,
                   int ind)

Set col to specified position

Parameters:: key -; ind -

setColAfter
```
public void setColAfter(C first,
                        C after)
```
set one col to follow another

Parameters:

first - Column we are to follow

after - Column to move

setColFormat

public Table.Formatter<C,R> setColFormat(C col_name,
                                         Table.Formatter<C,R> t)

setColFormat

public Table.Formatter setColFormat(C col_name,
                                    Transform t)

setColLast
```
public void setColLast(C key)
```
set col to last position

Parameters:

key -

setColName

public void setColName(C key,
                       java.lang.String name)

setColumns

public void setColumns(java.util.List<C> v)

setFormat
```
public void setFormat(Table.Formatter<C,R> t)
```
Set a printing format for all columns

Parameters:

t - Transform to use

setFormat
```
public void setFormat(Transform t)
```

setHighlight

public void setHighlight(R row_key,
                         boolean value)

mark a row to be highlighted

Parameters:: row_key -; value -

setKeyName
```
public void setKeyName(java.lang.String keyName)
```
Set the column name for the keys column this also causes the key column to be printed

Parameters:

keyName - String

setKeyTransform
```
public void setKeyTransform(Transform t)
```
Set a Transform used to print the keys.

Parameters:

t -

setPrintHeadings

public void setPrintHeadings(boolean printHeadings)

setRow

public void setRow(R key,
                   int ind)

set row to specified position

Parameters:: key -; ind -

setRowAfter

public void setRowAfter(R key,
                        R after)

setRowLast
```
public void setRowLast(R key)
```
set row to last position

Parameters:

key -

setTypeDebug
```
public void setTypeDebug(boolean flag)
```
add Java type information to output for debugging purposes.

Parameters:

flag -

setWarning

public void setWarning(R row_key,
                       boolean value)

mark a row to be highlighted

Parameters:: row_key -; value -

sortCols
```
public void sortCols(java.util.Comparator c)
```
Sort columns according to a specified comparator

Parameters:

c -

sortRows
```
public void sortRows()
```
sort rows using natural ordering of row keys

sortRows
```
public void sortRows(C[] keys,
                     boolean reverse)
```
Sort Rows by the natural ordering of a set of column values. additional keys are only used if there is a tie from previous keys.

Parameters:

keys - Array of column keys

reverse - boolean should order be reversed

sortRows
```
public void sortRows(java.util.Comparator c)
```
Sort rows according to row keys using a specified comparator

Parameters:

c -

sumCol
```
public double sumCol(C key)
```
sum the numerical values in a column

Parameters:

key -

Returns:

toString
```
public java.lang.String toString()
```
Overrides:

toString in class java.lang.Object

transformCol

public void transformCol(C col_name,
                         Transform t)

Apply a Transform to a column selected by name.

Parameters:: col_name -; t -

transformCol

public void transformCol(int col_index,
                         Transform t)

apply a Transform to a column selected by index.

Parameters:: col_index -; t -

transformKeys

public void transformKeys(C dest,
                          Transform t)

Create a new column based on a Transform applied to the current row keys.

Parameters:: dest -; t -

getId
```
public java.lang.String getId()
```

setId

public void setId(java.lang.String id)

thresholdRows
```
public <T> void thresholdRows(C col,
                              MatchCondition cond,
                              T value)
```
Remove all rows based on values in a column row is removed if col-value Condition value = true

Parameters:

col - Column to query

cond - MatchCondition to compare

value - value

addToGroup

public void addToGroup(C group,
                       C col)
                throws InvalidArgument

Throws:: InvalidArgument

getColumnGroup

public java.lang.Iterable<C> getColumnGroup(C name)

getColumnGroups
```
public java.lang.Iterable<C> getColumnGroups()
```
get all the defined Column Groups

Returns:

hasColumnGroup

public boolean hasColumnGroup(C name)

packColumnGroup
```
public void packColumnGroup(C name)
```
place all members of a column group after the first member of the group. If column names are generated dynamically then the first entry will be in the correct column position but subsequent rows may place additional column names at the end. This operation packs them into a contiguous group.

Parameters:

name -

packAllColumnGroups
```
public void packAllColumnGroups()
```
For all column groups. place member columns after the first member of the group. If column names are generated dynamically then the first entry will be in the correct column position but subsequent rows may place additional column names at the end. This operation packs them into contiguous groups.

Class Table<C,R>

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Table

Table

Method Detail

addColumnAsRow

add

addTable

addTable

addRows

addAttribute

addCategoryTotals

addCategoryTotals

setCategoryRow

addCategoryTotalToCol

addCategoryTotalToCol

addColAttribute

addMap

addMap

addNumber

addPercentCol

addPercentCol

addPercentCol

addPercentCol

addRow

addRow

addTotalToCol

addTotalToCol

colOperation

rowOperation

cols

containsCol

get

getAttributes

getCol

getColFormat

getCols

getColumNames

getHashtable

getHashtable

getHighlight

getKeyName

getKeyText

getNumber

getRows

getString

getText

getText

getWarning

hasCol

hasColFormat

hasData

hasRow

increment

isPrintHeadings

nCols

nRows

printKeys

put

putAfter

removeCol

removeRow

rows

rowToString

setCol

setColAfter

setColFormat

setColFormat

setColLast

setColName

setColumns

setFormat

setFormat

setHighlight

setKeyName

setKeyTransform