/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.uima.ruta.visitor;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.uima.cas.Feature;
import org.apache.uima.cas.FeatureStructure;
import org.apache.uima.cas.Type;
import org.apache.uima.cas.text.AnnotationFS;
import org.apache.uima.jcas.JCas;
import org.apache.uima.jcas.cas.DoubleArray;
import org.apache.uima.jcas.cas.IntegerArray;
import org.apache.uima.jcas.cas.StringArray;
import org.apache.uima.ruta.RutaElement;
import org.apache.uima.ruta.RutaStream;
import org.apache.uima.ruta.ScriptApply;
import org.apache.uima.ruta.action.AbstractRutaAction;
import org.apache.uima.ruta.condition.AbstractRutaCondition;
import org.apache.uima.ruta.rule.AbstractRule;
import org.apache.uima.ruta.rule.AbstractRuleMatch;
import org.apache.uima.ruta.type.Statistics;
import org.apache.uima.ruta.utils.UIMAUtils;
import org.apache.uima.ruta.verbalize.RutaVerbalizer;
public class StatisticsVisitor implements RutaInferenceVisitor {
private Map<String, Long> conditionTime;
private Map<String, Long> actionTime;
private Map<String, Integer> conditionAmount;
private Map<String, Integer> actionAmount;
private Map<String, Long> conditionDelta;
private Map<String, Long> actionDelta;
private RutaVerbalizer verbalizer;
public StatisticsVisitor(RutaVerbalizer verbalizer) {
super();
this.verbalizer = verbalizer;
conditionTime = new HashMap<String, Long>();
actionTime = new HashMap<String, Long>();
conditionAmount = new HashMap<String, Integer>();
actionAmount = new HashMap<String, Integer>();
conditionDelta = new HashMap<String, Long>();
actionDelta = new HashMap<String, Long>();
}
public void beginVisit(RutaElement element, ScriptApply result) {
if (element instanceof AbstractRutaCondition) {
AbstractRutaCondition c = (AbstractRutaCondition) element;
String name = verbalizer.verbalizeName(c);
Integer amount = conditionAmount.get(name);
if (amount == null)
amount = 0;
amount++;
conditionAmount.put(name, amount);
conditionDelta.put(name, System.currentTimeMillis());
} else if (element instanceof AbstractRutaAction) {
AbstractRutaAction a = (AbstractRutaAction) element;
String name = verbalizer.verbalizeName(a);
Integer amount = actionAmount.get(name);
if (amount == null)
amount = 0;
amount++;
actionAmount.put(name, amount);
actionDelta.put(name, System.currentTimeMillis());
}
}
public void endVisit(RutaElement element, ScriptApply result) {
if (element instanceof AbstractRutaCondition) {
AbstractRutaCondition c = (AbstractRutaCondition) element;
String name = verbalizer.verbalizeName(c);
Long start = conditionDelta.get(name);
long delta = System.currentTimeMillis() - start;
Long total = conditionTime.get(name);
if (total == null)
total = 0L;
total += delta;
conditionTime.put(name, total);
} else if (element instanceof AbstractRutaAction) {
AbstractRutaAction a = (AbstractRutaAction) element;
String name = verbalizer.verbalizeName(a);
Long start = actionDelta.get(name);
long delta = System.currentTimeMillis() - start;
Long total = actionTime.get(name);
if (total == null)
total = 0L;
total += delta;
actionTime.put(name, total);
}
}
public void finished(RutaStream stream, List<RutaInferenceVisitor> visitors) {
List<String> names = new ArrayList<String>();
List<Double> totals = new ArrayList<Double>();
List<Integer> amounts = new ArrayList<Integer>();
List<Double> parts = new ArrayList<Double>();
for (String each : conditionTime.keySet()) {
double total = conditionTime.get(each);
double amount = conditionAmount.get(each);
double part = total / amount;
part *= 10000;
part = Math.round(part);
part /= 10000;
names.add(each);
totals.add(total);
amounts.add((int) amount);
parts.add(part);
}
for (String each : actionTime.keySet()) {
double total = actionTime.get(each);
double amount = actionAmount.get(each);
double part = total / amount;
part *= 10000;
part = Math.round(part);
part /= 10000;
names.add(each);
totals.add(total);
amounts.add((int) amount);
parts.add(part);
}
JCas jCas = stream.getJCas();
StringArray nameArray = UIMAUtils.toStringArray(jCas, names.toArray(new String[] {}));
DoubleArray totalArray = UIMAUtils.toDoubleArray(jCas, getDoubleArray(totals));
IntegerArray amountArray = UIMAUtils.toIntegerArray(jCas, getIntegerArray(amounts));
DoubleArray partArray = UIMAUtils.toDoubleArray(jCas, getDoubleArray(parts));
Type type = jCas.getCasType(Statistics.type);
Feature fname = type.getFeatureByBaseName("name");
Feature ftotal = type.getFeatureByBaseName("total");
Feature famount = type.getFeatureByBaseName("amount");
Feature fparts = type.getFeatureByBaseName("part");
FeatureStructure fs = jCas.getCas().createFS(type);
fs.setFeatureValue(fname, nameArray);
fs.setFeatureValue(ftotal, totalArray);
fs.setFeatureValue(famount, amountArray);
fs.setFeatureValue(fparts, partArray);
jCas.getCas().addFsToIndexes(fs);
}
private int[] getIntegerArray(List<Integer> array) {
int[] result = new int[array.size()];
int i = 0;
for (Integer each : array) {
result[i++] = each;
}
return result;
}
private double[] getDoubleArray(List<Double> array) {
double[] result = new double[array.size()];
int i = 0;
for (Double each : array) {
result[i++] = each;
}
return result;
}
public Map<String, Long> getConditionTime() {
return conditionTime;
}
public Map<String, Long> getActionTime() {
return actionTime;
}
public Map<String, Integer> getConditionAmount() {
return conditionAmount;
}
public Map<String, Integer> getActionAmount() {
return actionAmount;
}
public void annotationAdded(AnnotationFS annotation,
AbstractRuleMatch<? extends AbstractRule> creator) {
}
}