package timeflow.data.db;
|
|
import timeflow.data.db.filter.*;
|
import timeflow.data.time.*;
|
import timeflow.util.*;
|
|
import java.util.*;
|
|
public class DBUtils
|
{
|
|
public static void dump(Act act)
|
{
|
List<Field> fields = act.getDB().getFields();
|
for (Field f : fields)
|
{
|
System.out.println(f.getName() + " = " + act.get(f));
|
}
|
}
|
|
public static Object get(Act act, String field)
|
{
|
return act.get(act.getDB().getField(field));
|
}
|
|
public static List<String> getFieldAliases(ActDB db)
|
{
|
ArrayList<String> list = new ArrayList<String>();
|
for (String s : db.getFieldKeys())
|
{
|
if (!db.getField(s).getName().equals(s))
|
{
|
list.add(s);
|
}
|
}
|
return list;
|
}
|
|
public static Interval range(ActList a, Field[] fields)
|
{
|
if (fields == null || fields.length == 0)
|
{
|
return new Interval(0, 0);
|
}
|
Interval t = null;
|
for (Act act : a)
|
{
|
for (Field f : fields)
|
{
|
RoughTime d = act.getTime(f);
|
if (d != null && d.isDefined())
|
{
|
if (t == null)
|
{
|
t = new Interval(d.getTime(), d.getTime());
|
} else
|
{
|
t.include(d.getTime());
|
}
|
}
|
}
|
}
|
return t != null ? t : new Interval(RoughTime.UNKNOWN, RoughTime.UNKNOWN);
|
}
|
|
public static Interval range(ActList a, String fieldName)
|
{
|
|
Field field = a.getDB().getField(fieldName);
|
if (field == null || a.size() == 0)
|
{
|
return new Interval(0, 0);
|
}
|
Interval t = null;
|
for (Act act : a)
|
{
|
RoughTime d = act.getTime(field);
|
if (d != null && d.isDefined())
|
{
|
if (t == null)
|
{
|
t = new Interval(d.getTime(), d.getTime());
|
} else
|
{
|
t.include(d.getTime());
|
}
|
}
|
}
|
return t != null ? t : new Interval(RoughTime.UNKNOWN, RoughTime.UNKNOWN);
|
}
|
|
public static List<Field> categoryFields(ActDB db)
|
{
|
List<Field> list = new ArrayList<Field>();
|
list.addAll(db.getFields());
|
// list.addAll(db.getFields(String.class));
|
// list.addAll(db.getFields(String[].class));
|
return list;
|
}
|
|
public static int count(Iterable<Act> acts, Interval i, Field field)//String fieldName)
|
{
|
return count(acts, new TimeIntervalFilter(i, field));
|
}
|
|
public static int count(Iterable<Act> acts, ActFilter filter)
|
{
|
int num = 0;
|
for (Act a : acts)
|
{
|
if (filter.accept(a))
|
{
|
num++;
|
}
|
}
|
return num;
|
}
|
|
public static double[] minmax(Iterable<Act> acts, Field field)
|
{
|
double min = Double.NaN;
|
double max = min;
|
for (Act a : acts)
|
{
|
double x = a.getValue(field);
|
if (Double.isNaN(min))
|
{
|
min = x;
|
max = x;
|
} else if (!Double.isNaN(x))
|
{
|
min = Math.min(x, min);
|
max = Math.max(x, max);
|
}
|
}
|
return new double[]
|
{
|
min, max
|
};
|
}
|
|
public static double[] getValues(Iterable<Act> acts, Field field)
|
{
|
ArrayList<Double> list = new ArrayList<Double>();
|
if (field.getType() == Double.class)
|
{
|
for (Act a : acts)
|
{
|
list.add(a.getValue(field));
|
}
|
} else if (field.getType() == RoughTime.class)
|
{
|
for (Act a : acts)
|
{
|
RoughTime r = a.getTime(field);
|
if (r != null)
|
{
|
list.add(new Double(r.getTime()));
|
}
|
}
|
}
|
int n = list.size();
|
double[] x = new double[n];
|
for (int i = 0; i < n; i++)
|
{
|
x[i] = list.get(i);
|
}
|
return x;
|
}
|
|
public static Bag<String> countValues(Iterable<Act> acts, Field field)
|
{
|
Bag<String> bag = new Bag<String>();
|
if (field.getType() != String[].class)
|
{
|
for (Act a : acts)
|
{
|
bag.add(a.getString(field));
|
}
|
}
|
else // if (field.getType() == String[].class)
|
{
|
for (Act a : acts)
|
{
|
String[] s = a.getTextList(field);
|
if (s != null)
|
{
|
for (int i = 0; i < s.length; i++)
|
{
|
bag.add(s[i]);
|
}
|
}
|
}
|
// } else
|
// {
|
// throw new IllegalArgumentException("Asked to count values for non-text field: " + field);
|
}
|
return bag;
|
}
|
|
public static void setRecSizesFromCurrent(ActDB db)
|
{
|
// for String fields.
|
for (Field f : db.getFields(String.class))
|
{
|
int max = 0;
|
for (Act a : db)
|
{
|
String s = a.getString(f);
|
if (s != null)
|
{
|
max = Math.max(s.length(), max);
|
}
|
}
|
f.setRecommendedSize(max);
|
}
|
}
|
|
public static Field ensureField(ActDB db, String name, Class type)
|
{
|
Field f = db.getField(name);
|
if (f == null)
|
{
|
return db.addField(name, type);
|
} else
|
{
|
if (f.getType() != type)
|
{
|
throw new IllegalArgumentException("Mismatched types: got " + type + ", expected " + f.getType());
|
}
|
}
|
return f;
|
}
|
}
|
