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;

boolean binary = false;

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("bin")) {

binary = true;

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

header = true;

} else {

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

}

}

}

if (binary) {

loadBinary(input);

} else {

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++;

ensureColumn(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 boolean save(File file, String options) throws IOException {

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

}

public boolean 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 if (opt.equals("bin")) {

try {

saveBinary(output);

} catch (IOException e) {

e.printStackTrace();

return false;

}

} else {

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

"Only csv, tsv, and html are " +

"accepted as save parameters");

}

}

}

writer.close();

return true;

}

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);

}

}

}

protected void saveBinary(OutputStream os) throws IOException {

DataOutputStream output = new DataOutputStream(new BufferedOutputStream(os));

output.writeInt(0x9007AB1E); // version

output.writeInt(getRowCount());

output.writeInt(getColumnCount());

if (columnTitles != null) {

output.writeBoolean(true);

for (String title : columnTitles) {

output.writeUTF(title);

}

} else {

output.writeBoolean(false);

}

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

//System.out.println(i + " is " + columnTypes[i]);

output.writeInt(columnTypes[i]);

}

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

if (columnTypes[i] == CATEGORICAL) {

columnCategories[i].write(output);

}

}

if (missingString == null) {

output.writeBoolean(false);

} else {

output.writeBoolean(true);

output.writeUTF(missingString);

}

output.writeInt(missingInt);

output.writeLong(missingLong);

output.writeFloat(missingFloat);

output.writeDouble(missingDouble);

output.writeInt(missingCategory);

for (TableRow row : rows()) {

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

switch (columnTypes[col]) {

case STRING:

output.writeUTF(row.getString(col));

break;

case INT:

output.writeInt(row.getInt(col));

break;

case LONG:

output.writeLong(row.getLong(col));

break;

case FLOAT:

output.writeFloat(row.getFloat(col));

break;

case DOUBLE:

output.writeDouble(row.getDouble(col));

break;

case CATEGORICAL:

output.writeInt(columnCategories[col].index(row.getString(col)));

break;

}

}

}

output.flush();

output.close();

}

protected void loadBinary(InputStream is) throws IOException {

DataInputStream input = new DataInputStream(new BufferedInputStream(is));

int magic = input.readInt();

if (magic != 0x9007AB1E) {

throw new IOException("Not a compatible binary table (magic was " + PApplet.hex(magic) + ")");

}

int rowCount = input.readInt();

setRowCount(rowCount);

int columnCount = input.readInt();

setColumnCount(columnCount);

boolean hasTitles = input.readBoolean();

if (hasTitles) {

columnTitles = new String[getColumnCount()];

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

//columnTitles[i] = input.readUTF();

setColumnTitle(i, input.readUTF());

}

}

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

int newType = input.readInt();

columnTypes[column] = newType;

switch (newType) {

case INT:

columns[column] = new int[rowCount];

break;

case LONG:

columns[column] = new long[rowCount];;

break;

case FLOAT:

columns[column] = new float[rowCount];;

break;

case DOUBLE:

columns[column] = new double[rowCount];;

break;

case STRING:

columns[column] = new String[rowCount];;

break;

case CATEGORICAL:

columns[column] = new int[rowCount];;

break;

default:

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

}

}

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

if (columnTypes[i] == CATEGORICAL) {

columnCategories[i] = new HashMapBlows(input);

}

}

if (input.readBoolean()) {

missingString = input.readUTF();

} else {

missingString = null;

}

missingInt = input.readInt();

missingLong = input.readLong();

missingFloat = input.readFloat();

missingDouble = input.readDouble();

missingCategory = input.readInt();

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

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

switch (columnTypes[col]) {

case STRING:

setString(row, col, input.readUTF());

break;

case INT:

setInt(row, col, input.readInt());

break;

case LONG:

setLong(row, col, input.readLong());

break;

case FLOAT:

setFloat(row, col, input.readFloat());

break;

case DOUBLE:

setDouble(row, col, input.readDouble());

break;

case CATEGORICAL:

int index = input.readInt();

//String name = columnCategories[col].key(index);

setInt(row, col, index);

break;

}

}

}

input.close();

}

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

public void addColumn() {

addColumn(null, STRING);

}

public void addColumn(String title) {

addColumn(title, STRING);

}

public void addColumn(String title, int type) {