package timeflow.data.db;
|
|
import java.net.URL;
|
import java.util.*;
|
|
import timeflow.data.db.filter.*;
|
import timeflow.data.time.*;
|
|
public class ArrayDB implements ActDB
|
{
|
|
private Schema schema;
|
private List<Act> data = new ArrayList<Act>();
|
private Field[] fields;
|
private String source = "[unknown]";
|
private String description = "";
|
|
public String getDescription()
|
{
|
return description;
|
}
|
|
public void setDescription(String description)
|
{
|
this.description = description;
|
}
|
|
public String getSource()
|
{
|
return source;
|
}
|
|
public void setSource(String source)
|
{
|
this.source = source;
|
}
|
|
@Override
|
public void setAlias(Field field, String name)
|
{
|
schema.addAlias(field, name);
|
}
|
|
public ArrayDB(String[] fieldNames, Class[] types, String source)
|
{
|
this.schema = new Schema();
|
this.source = source;
|
int n = fieldNames.length;
|
fields = new Field[n];
|
for (int i = 0; i < n; i++)
|
{
|
fields[i] = schema.add(fieldNames[i], types[i]);
|
fields[i].index = i;
|
}
|
}
|
|
public Field[] getFieldArray()
|
{
|
return fields;
|
}
|
|
@Override
|
public Field addField(String name, Class type)
|
{
|
|
int n = fields.length;
|
|
// make new Field.
|
Field field = new Field(name, type);
|
field.index = n;
|
|
// make new array of fields.
|
Field[] moreFields = new Field[n + 1];
|
System.arraycopy(fields, 0, moreFields, 0, n);
|
moreFields[n] = field;
|
this.fields = moreFields;
|
|
// go through all the data items and expand their arrays, too.
|
for (Act d : data)
|
{
|
IndexedAct item = (IndexedAct) d;
|
Object[] old = item.data;
|
item.data = new Object[n + 1];
|
System.arraycopy(old, 0, item.data, 0, n);
|
}
|
|
//System.out.println("Field added: "+field);
|
schema.add(field);
|
|
return field;
|
}
|
|
public Field getField(String name)
|
{
|
return schema.getField(name);
|
}
|
|
@Override
|
public ActList all()
|
{
|
return select(null);
|
}
|
|
@Override
|
public Act createAct()
|
{
|
IndexedAct act = new IndexedAct(this, fields.length);
|
data.add(act);
|
return act;
|
}
|
|
@Override
|
public void delete(Act act)
|
{
|
data.remove(act);
|
}
|
|
@Override
|
public void deleteField(Field deadField)
|
{
|
|
System.out.println("Deleting: " + deadField);
|
|
schema.delete(deadField);
|
int n = fields.length;
|
int m = deadField.index;
|
|
// make new array of fields.
|
Field[] fewerFields = new Field[n - 1];
|
removeItem(fields, fewerFields, m);
|
fields = fewerFields;
|
|
// go through all the data items and contract their arrays, too.
|
for (Act d : data)
|
{
|
IndexedAct item = (IndexedAct) d;
|
Object[] old = item.data;
|
item.data = new Object[n - 1];
|
removeItem(old, item.data, m);
|
}
|
|
// change field indices
|
for (int i = 0; i < fields.length; i++)
|
{
|
System.out.println("fields[" + i + "]=" + fields[i]);
|
if (fields[i].index > deadField.index)
|
{
|
fields[i].index--;
|
}
|
}
|
}
|
|
private static void removeItem(Object[] a, Object[] b, int m)
|
{
|
int n = a.length;
|
if (m > 0)
|
{
|
System.arraycopy(a, 0, b, 0, m);
|
}
|
if (m < n - 1)
|
{
|
System.arraycopy(a, m + 1, b, m, n - m - 1);
|
}
|
}
|
|
@Override
|
public List<Field> getFields(Class type)
|
{
|
return schema.getFields(type);
|
}
|
|
@Override
|
public ActList select(ActFilter filter)
|
{
|
ActList set = new ActList(this);
|
for (Act a : data)
|
{
|
if (filter == null || filter.accept(a))
|
{
|
set.add(a);
|
}
|
}
|
return set;
|
}
|
|
@Override
|
public List<Field> getFields()
|
{
|
return schema.getFields();
|
}
|
|
@Override
|
public Act get(int i)
|
{
|
return data.get(i);
|
}
|
|
@Override
|
public int size()
|
{
|
return data.size();
|
}
|
|
@Override
|
public Iterator<Act> iterator()
|
{
|
return data.iterator();
|
}
|
|
@Override
|
public List<String> getFieldKeys()
|
{
|
return schema.getKeys();
|
}
|
|
@Override
|
public void setNewFieldOrder(List<Field> newOrder)
|
{
|
schema.setNewFieldOrder(newOrder);
|
}
|
|
class IndexedAct implements Act
|
{
|
|
Object[] data;
|
ActDB db;
|
|
IndexedAct(ActDB db, int numFields)
|
{
|
this.db = db;
|
data = new Object[numFields];
|
}
|
|
@Override
|
public String getString(Field field)
|
{
|
|
Object obj = data[field.index];
|
|
if (obj == null)
|
return null;
|
|
if (obj instanceof String[])
|
{
|
String[] strings = (String[]) obj;
|
String string = "";
|
for (String s : strings)
|
{
|
string += s + ", ";
|
}
|
return string;
|
} else
|
{
|
return obj.toString();
|
}
|
}
|
|
public void setText(Field field, String text)
|
{
|
data[field.index] = text;
|
}
|
|
@Override
|
public String[] getTextList(Field field)
|
{
|
Object obj = data[field.index];
|
|
if (obj == null)
|
return null;
|
|
if (obj instanceof String[])
|
{
|
return (String[]) obj;
|
} else
|
{
|
return new String[]
|
{
|
obj.toString()
|
};
|
}
|
}
|
|
public void setTextList(Field field, String[] list)
|
{
|
data[field.index] = list;
|
}
|
|
@Override
|
public double getValue(Field field)
|
{
|
Double d = (Double) data[field.index];
|
return d == null ? Double.NaN : d.doubleValue();
|
}
|
|
public void setValue(Field field, double value)
|
{
|
data[field.index] = value;
|
}
|
|
@Override
|
public Object get(Field field)
|
{
|
return data[field.index];
|
}
|
|
@Override
|
public ActDB getDB()
|
{
|
return db;
|
}
|
|
@Override
|
public void set(Field field, Object value)
|
{
|
data[field.index] = value;
|
}
|
|
@Override
|
public RoughTime getTime(Field field)
|
{
|
return (RoughTime) data[field.index];
|
}
|
|
@Override
|
public void setTime(Field field, RoughTime time)
|
{
|
data[field.index] = time;
|
}
|
|
@Override
|
public URL getURL(Field field)
|
{
|
return (URL) data[field.index];
|
}
|
|
@Override
|
public void setURL(Field field, URL url)
|
{
|
data[field.index] = url;
|
}
|
}
|
|
@Override
|
public void renameField(Field field, String name)
|
{
|
schema.renameField(field, name);
|
}
|
}
|
