protected int rowCount;

protected String missingString = null;

protected int missingInt = 0;

protected long missingLong = 0;

protected float missingFloat = Float.NaN;

protected double missingDouble = Double.NaN;

protected int missingCategory = -1;

String[] columnTitles;

HashMapBlows[] columnCategories;

HashMap<String, Integer> columnIndices;

protected Object[] columns; // [column]

static final int STRING = 0;

static final int INT = 1;

static final int LONG = 2;

static final int FLOAT = 3;

static final int DOUBLE = 4;

static final int CATEGORICAL = 5;

int[] columnTypes;

protected RowIterator rowIterator;

/**

public Table() {

init();

}

public Table(File file) throws IOException {

this(file, null);

}

// version that uses a File object; future releases (or data types)

// may include additional optimizations here

public Table(File file, String options) throws IOException {

parse(new FileInputStream(file), checkOptions(file, options));

}

public Table(InputStream input) throws IOException {

this(input, null);

}

/**

public Table(InputStream input, String options) throws IOException {

parse(input, options);

}

public Table(ResultSet rs) {

init();

try {

ResultSetMetaData rsmd = rs.getMetaData();

int columnCount = rsmd.getColumnCount();

setColumnCount(columnCount);

for (int col = 0; col < columnCount; col++) {

setColumnTitle(col, rsmd.getColumnName(col + 1));

int type = rsmd.getColumnType(col + 1);

switch (type) { // TODO these aren't tested. nor are they complete.

case Types.INTEGER:

case Types.TINYINT:

case Types.SMALLINT:

setColumnType(col, INT);

break;

case Types.BIGINT:

setColumnType(col, LONG);

break;

case Types.FLOAT:

setColumnType(col, FLOAT);

break;

case Types.DECIMAL:

case Types.DOUBLE:

case Types.REAL:

setColumnType(col, DOUBLE);

break;

}

}

int row = 0;

while (rs.next()) {

for (int col = 0; col < columnCount; col++) {

switch (columnTypes[col]) {

case STRING: setString(row, col, rs.getString(col+1)); break;

case INT: setInt(row, col, rs.getInt(col+1)); break;

case LONG: setLong(row, col, rs.getLong(col+1)); break;

case FLOAT: setFloat(row, col, rs.getFloat(col+1)); break;

case DOUBLE: setDouble(row, col, rs.getDouble(col+1)); break;

default: throw new IllegalArgumentException("column type " + columnTypes[col] + " not supported.");

}

}

row++;

}

} catch (SQLException s) {

throw new RuntimeException(s);

}

}

protected void init() {

columns = new Object[0];

columnTypes = new int[0];

columnCategories = new HashMapBlows[0];

}

protected String checkOptions(File file, String options) throws IOException {

String extension = null;

String filename = file.getName();

int dotIndex = filename.lastIndexOf('.');

if (dotIndex != -1) {

extension = filename.substring(dotIndex + 1).toLowerCase();

if (!extension.equals("csv") &&

!extension.equals("tsv")) {

// ignore extension

extension = null;

}

}

if (extension == null) {

if (options == null) {

throw new IOException("This table filename has no extension, and no options are set.");

}

} else { // extension is not null

if (options == null) {

options = extension;

} else {

// prepend the extension, it will be overridden if there's an option for it.

options = extension + "," + options;

}

}

return options;

}

protected void parse(InputStream input, String options) throws IOException {

init();

boolean awfulCSV = false;

boolean header = false;

String extension = null;

if (options != null) {

String[] opts = PApplet.splitTokens(options, " ,");

for (String opt : opts) {

if (opt.equals("tsv")) {

extension = "tsv";

} else if (opt.equals("csv")) {

extension = "csv";

} else if (opt.equals("newlines")) {

awfulCSV = true;

} else if (opt.equals("header")) {

header = true;

} else {

throw new IllegalArgumentException("'" + opt + "' is not a valid option for loading a Table");

}

}

}

BufferedReader reader = PApplet.createReader(input);

if (awfulCSV) {

parseAwfulCSV(reader, header);

} else if ("tsv".equals(extension)) {

parseBasic(reader, header, true);

} else if ("csv".equals(extension)) {

parseBasic(reader, header, false);

}

}

protected void parseBasic(BufferedReader reader,

boolean header, boolean tsv) throws IOException {

String line = null;

int row = 0;

if (rowCount == 0) {

setRowCount(10);

}

//int prev = 0; //-1;

while ((line = reader.readLine()) != null) {

if (row == getRowCount()) {

setRowCount(row << 1);

}

if (row == 0 && header) {

setColumnTitles(tsv ? PApplet.split(line, '\t') : splitLineCSV(line));

header = false;

} else {

setRow(row, tsv ? PApplet.split(line, '\t') : splitLineCSV(line));

row++;

}

/*

}

// shorten or lengthen based on what's left

if (row != getRowCount()) {

setRowCount(row);

}

}

protected void parseAwfulCSV(BufferedReader reader,

boolean header) throws IOException {

char[] c = new char[100];

int count = 0;

boolean insideQuote = false;

int row = 0;

int col = 0;

int ch;

while ((ch = reader.read()) != -1) {

if (insideQuote) {

if (ch == '\"') {

// this is either the end of a quoted entry, or a quote character

reader.mark(1);

if (reader.read() == '\"') {

// it's "", which means a quote character

if (count == c.length) {

c = PApplet.expand(c);

}

c[count++] = '\"';

} else {

// nope, just the end of a quoted csv entry

reader.reset();

insideQuote = false;

// TODO nothing here that prevents bad csv data from showing up

// after the quote and before the comma...

}

} else { // inside a quote, but the character isn't a quote

if (count == c.length) {

c = PApplet.expand(c);

}

c[count++] = (char) ch;

}

} else { // not inside a quote

if (ch == '\"') {

insideQuote = true;

} else if (ch == '\r' || ch == '\n') {

if (ch == '\r') {

// check to see if next is a '\n'

reader.mark(1);

if (reader.read() != '\n') {

reader.reset();

}

}

setString(row, col, new String(c, 0, count));

count = 0;

if (row == 0 && header) {

// Use internal row removal (efficient because only one row).

removeTitleRow();

// Un-set the header variable so that next time around, we don't

// just get stuck into a loop, removing the 0th row repeatedly.

header = false;

}

row++;

col = 0;

} else if (ch == ',') {

setString(row, col, new String(c, 0, count));

count = 0;

// starting a new column, make sure we have room

col++;

checkColumn(col);

} else { // just a regular character, add it

if (count == c.length) {

c = PApplet.expand(c);

}

c[count++] = (char) ch;

}

}

}

// catch any leftovers

if (count > 0) {

setString(row, col, new String(c, 0, count));

}

}

/**

static protected String[] splitLineCSV(String line) {

char[] c = line.toCharArray();

int rough = 1; // at least one

boolean quote = false;

for (int i = 0; i < c.length; i++) {

if (!quote && (c[i] == ',')) {

rough++;

} else if (c[i] == '\"') {

quote = !quote;

}

}

String[] pieces = new String[rough];

int pieceCount = 0;

int offset = 0;

while (offset < c.length) {

int start = offset;

int stop = nextComma(c, offset);

offset = stop + 1; // next time around, need to step over the comment

if (c[start] == '\"' && c[stop-1] == '\"') {

start++;

stop--;

}

int i = start;

int ii = start;

while (i < stop) {

if (c[i] == '\"') {

i++; // skip over pairs of double quotes become one

}

if (i != ii) {

c[ii] = c[i];

}

i++;

ii++;

}

String s = new String(c, start, ii - start);

pieces[pieceCount++] = s;

}

// make any remaining entries blanks instead of nulls

for (int i = pieceCount; i < pieces.length; i++) {

pieces[i] = "";

}

return pieces;

}

static protected int nextComma(char[] c, int index) {

boolean quote = false;

for (int i = index; i < c.length; i++) {

if (!quote && (c[i] == ',')) {

return i;

} else if (c[i] == '\"') {

quote = !quote;

}

}

return c.length;

}

// A 'Class' object is used here, so the syntax for this function is:

// Table t = loadTable("cars3.tsv", "header");

// Record[] records = (Record[]) t.parse(Record.class);

// While t.parse("Record") might be nicer, the class is likely to be an

// inner class (another tab in a PDE sketch) or even inside a package,

// so additional information would be needed to locate it. The name of the

// inner class would be "SketchName$Record" which isn't acceptable syntax

// to make people use. Better to just introduce the '.class' syntax.

// Unlike the Table class itself, this accepts char and boolean fields in

// the target class, since they're much more prevalent, and don't require

// a zillion extra methods and special cases in the rest of the class here.

// since this is likely an inner class, needs a reference to its parent,

// because that's passed to the constructor parameter (inserted by the

// compiler) of an inner class by the runtime.

/** incomplete, do not use */

public void parseInto(Object enclosingObject, String fieldName) {

Class<?> target = null;

Object outgoing = null;

Field targetField = null;

try {

// Object targetObject,

// Class target -> get this from the type of fieldName

Class<?> sketchClass = enclosingObject.getClass();

targetField = sketchClass.getDeclaredField(fieldName);

Class<?> targetArray = targetField.getType();

if (!targetArray.isArray()) {

// fieldName is not an array

} else {

target = targetArray.getComponentType();

outgoing = Array.newInstance(target, getRowCount());

}

} catch (NoSuchFieldException e) {

e.printStackTrace();

} catch (SecurityException e) {

e.printStackTrace();

}

Class<?> enclosingClass = target.getEnclosingClass();

Constructor<?> con = null;

try {

if (enclosingClass == null) {

con = target.getDeclaredConstructor(); //new Class[] { });

} else {

con = target.getDeclaredConstructor(new Class[] { enclosingClass });

}

if (!con.isAccessible()) {

con.setAccessible(true);

}

} catch (SecurityException e) {

e.printStackTrace();

} catch (NoSuchMethodException e) {

e.printStackTrace();

}

Field[] fields = target.getDeclaredFields();

ArrayList<Field> inuse = new ArrayList<Field>();

for (Field field : fields) {

String name = field.getName();

if (getColumnIndex(name, false) != -1) {

if (!field.isAccessible()) {

field.setAccessible(true);

}

inuse.add(field);

} else {

}

}

int index = 0;

try {

for (TableRow row : rows()) {

Object item = null;

if (enclosingClass == null) {

//item = target.newInstance();

item = con.newInstance();

} else {

item = con.newInstance(new Object[] { enclosingObject });

}

//Object item = defaultCons.newInstance(new Object[] { });

for (Field field : inuse) {

String name = field.getName();

//PApplet.println("gonna set field " + name);

if (field.getType() == String.class) {

field.set(item, row.getString(name));

} else if (field.getType() == Integer.TYPE) {

field.setInt(item, row.getInt(name));

} else if (field.getType() == Long.TYPE) {

field.setLong(item, row.getLong(name));

} else if (field.getType() == Float.TYPE) {

field.setFloat(item, row.getFloat(name));

} else if (field.getType() == Double.TYPE) {

field.setDouble(item, row.getDouble(name));

} else if (field.getType() == Boolean.TYPE) {

String content = row.getString(name);

if (content != null) {

// Only bother setting if it's true,

// otherwise false by default anyway.

if (content.toLowerCase().equals("true") ||

content.equals("1")) {

field.setBoolean(item, true);

}

}

} else if (field.getType() == Character.TYPE) {

String content = row.getString(name);

if (content != null && content.length() > 0) {

// Otherwise set to \0 anyway

field.setChar(item, content.charAt(0));

}

}

}

Array.set(outgoing, index++, item);

}

if (!targetField.isAccessible()) {

targetField.setAccessible(true);

}

// Set the array in the sketch

targetField.set(enclosingObject, outgoing);

} catch (InstantiationException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

} catch (IllegalArgumentException e) {

e.printStackTrace();

} catch (InvocationTargetException e) {

e.printStackTrace();

}

}

public void save(File file, String options) throws IOException {

save(new FileOutputStream(file), checkOptions(file, options));

}

public void save(OutputStream output, String options) {

PrintWriter writer = PApplet.createWriter(output);

if (options != null) {

String[] opts = PApplet.splitTokens(options, ", ");

for (String opt : opts) {

if (opt.equals("csv")) {

writeCSV(writer);

} else if (opt.equals("tsv")) {

writeTSV(writer);

} else if (opt.equals("html")) {

writeHTML(writer);

} else {

throw new IllegalArgumentException("'" + opt + "' not understood. " +

"Only csv, tsv, and html are " +

"accepted as save parameters");

}

}

}

writer.close();

}

protected void writeTSV(PrintWriter writer) {

if (columnTitles != null) {

for (int col = 0; col < columns.length; col++) {

if (col != 0) {

writer.print('\t');

}

if (columnTitles[col] != null) {

writer.print(columnTitles[col]);

}

}

writer.println();

}

for (int row = 0; row < rowCount; row++) {

for (int col = 0; col < getColumnCount(); col++) {

if (col != 0) {

writer.print('\t');

}

String entry = getString(row, col);

// just write null entries as blanks, rather than spewing 'null'

// all over the spreadsheet file.

if (entry != null) {

writer.print(entry);

}

}

writer.println();

}

writer.flush();

}

protected void writeCSV(PrintWriter writer) {

if (columnTitles != null) {

for (int col = 0; col < columns.length; col++) {

if (col != 0) {

writer.print(',');

}

if (columnTitles[col] != null) {

writeEntryCSV(writer, columnTitles[col]);

}

}

writer.println();

}

for (int row = 0; row < rowCount; row++) {

for (int col = 0; col < getColumnCount(); col++) {

if (col != 0) {

writer.print(',');

}

String entry = getString(row, col);

// just write null entries as blanks, rather than spewing 'null'

// all over the spreadsheet file.

if (entry != null) {

writeEntryCSV(writer, entry);

}

}

// Prints the newline for the row, even if it's missing

writer.println();

}

writer.flush();

}

protected void writeEntryCSV(PrintWriter writer, String entry) {

if (entry != null) {

if (entry.indexOf('\"') != -1) { // convert quotes to double quotes

char[] c = entry.toCharArray();

writer.print('\"');

for (int i = 0; i < c.length; i++) {

if (c[i] == '\"') {

writer.print("\"\"");

} else {

writer.print(c[i]);

}

}

writer.print('\"');

// add quotes if commas or CR/LF are in the entry

} else if (entry.indexOf(',') != -1 ||

entry.indexOf('\n') != -1 ||

entry.indexOf('\r') != -1) {

writer.print('\"');

writer.print(entry);

writer.print('\"');

// add quotes if leading or trailing space

} else if ((entry.length() > 0) &&

(entry.charAt(0) == ' ' ||

entry.charAt(entry.length() - 1) == ' ')) {

writer.print('\"');

writer.print(entry);

writer.print('\"');

} else {

writer.print(entry);

}

}

}

protected void writeHTML(PrintWriter writer) {

writer.println("<html>");

writer.println("<head>");

writer.println(" <meta http-equiv=\"content-type\" content=\"text/html;charset=utf-8\" />");

writer.println("</head>");

writer.println("<body>");

writer.println(" <table>");

for (int row = 0; row < getRowCount(); row++) {

writer.println(" <tr>");

for (int col = 0; col < getColumnCount(); col++) {

String entry = getString(row, col);

writer.print(" <td>");

writeEntryHTML(writer, entry);

writer.println(" </td>");

}

writer.println(" </tr>");

}

writer.println(" </table>");

writer.println("</body>");

writer.println("</hmtl>");

writer.flush();

}

protected void writeEntryHTML(PrintWriter writer, String entry) {

//char[] chars = entry.toCharArray();

for (char c : entry.toCharArray()) { //chars) {

if (c == '<') {

writer.print("&lt;");

} else if (c == '>') {

writer.print("&gt;");

} else if (c == '&') {

writer.print("&amp;");

} else if (c == '\'') {

writer.print("&apos;");

} else if (c == '"') {

writer.print("&quot;");

// not necessary with UTF-8?

} else {

writer.print(c);

}

}

}

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

public void addColumn() {

addColumn(null, STRING);

}

public void addColumn(String title) {

addColumn(title, STRING);

}

public void addColumn(String title, int type) {

insertColumn(columns.length, title, type);

}

public void insertColumn(int index) {

insertColumn(index, null, STRING);

}

public void insertColumn(int index, String title) {

insertColumn(index, title, STRING);

}

public void insertColumn(int index, String title, int type) {

if (title != null && columnTitles == null) {

columnTitles = new String[columns.length];

}

if (columnTitles != null) {

columnTitles = PApplet.splice(columnTitles, title, index);

columnIndices = null;

}

columnTypes = PApplet.splice(columnTypes, type, index);

HashMapBlows[] catTemp = new HashMapBlows[columns.length + 1];

// Faster than arrayCopy for a dozen or so entries

for (int i = 0; i < index; i++) {

catTemp[i] = columnCategories[i];

}

catTemp[index] = new HashMapBlows();

for (int i = index; i < columns.length; i++) {

catTemp[i+1] = columnCategories[i];

}

columnCategories = catTemp;

Object[] temp = new Object[columns.length + 1];

System.arraycopy(columns, 0, temp, 0, index);

System.arraycopy(columns, index, temp, index+1, columns.length - index);

columns = temp;

switch (type) {

case INT: columns[index] = new int[rowCount]; break;

case LONG: columns[index] = new long[rowCount]; break;

case FLOAT: columns[index] = new float[rowCount]; break;

case DOUBLE: columns[index] = new double[rowCount]; break;

case STRING: columns[index] = new String[rowCount]; break;

case CATEGORICAL: columns[index] = new int[rowCount]; break;

}

}

public void removeColumn(String columnName) {

removeColumn(getColumnIndex(columnName));

}

public void removeColumn(int column) {

Object[] temp = new Object[columns.length + 1];

System.arraycopy(columns, 0, temp, 0, column);

System.arraycopy(columns, column+1, temp, column, (columns.length - column) + 1);

columns = temp;

}

public int getColumnCount() {

return columns.length;

}

/**

public void setColumnCount(int newCount) {

int oldCount = columns.length;

if (oldCount != newCount) {

columns = (Object[]) PApplet.expand(columns, newCount);

// create new columns, default to String as the data type

for (int c = oldCount; c < newCount; c++) {

columns[c] = new String[rowCount];

}

if (columnTitles != null) {

columnTitles = PApplet.expand(columnTitles, newCount);

}

columnTypes = PApplet.expand(columnTypes, newCount);

columnCategories = (HashMapBlows[])

PApplet.expand(columnCategories, newCount);

}

}

public void setColumnType(String columnName, String columnType) {

setColumnType(checkColumnIndex(columnName), columnType);

}

/**

public void setColumnType(int column, String columnType) {

int type = -1;

if (columnType.equals("String")) {

type = STRING;

} else if (columnType.equals("int")) {

type = INT;

} else if (columnType.equals("long")) {

type = LONG;

} else if (columnType.equals("float")) {

type = FLOAT;

} else if (columnType.equals("double")) {

type = DOUBLE;

} else if (columnType.equals("categorical")) {

type = CATEGORICAL;

} else {

throw new IllegalArgumentException("'" + columnType + "' is not a valid column type.");

}

setColumnType(column, type);

}

protected void setColumnType(String columnName, int newType) {

setColumnType(checkColumnIndex(columnName), newType);

}

/**

protected void setColumnType(int column, int newType) {

switch (newType) {

case INT: {

int[] intData = new int[rowCount];

for (int row = 0; row < rowCount; row++) {

String s = getString(row, column);

intData[row] = PApplet.parseInt(s, missingInt);

}

columns[column] = intData;

break;

}

case LONG: {

long[] longData = new long[rowCount];

for (int row = 0; row < rowCount; row++) {

String s = getString(row, column);

try {

longData[row] = Long.parseLong(s);

} catch (NumberFormatException nfe) {

longData[row] = missingLong;

}

}

columns[column] = longData;

break;

}

case FLOAT: {

float[] floatData = new float[rowCount];

for (int row = 0; row < rowCount; row++) {

String s = getString(row, column);

floatData[row] = PApplet.parseFloat(s, missingFloat);

}

columns[column] = floatData;

break;

}

case DOUBLE: {

double[] doubleData = new double[rowCount];

for (int row = 0; row < rowCount; row++) {

String s = getString(row, column);

try {

doubleData[row] = Double.parseDouble(s);