/* | |
* 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 java.util.Stack; | |
import org.apache.uima.cas.text.AnnotationFS; | |
import org.apache.uima.ruta.BlockApply; | |
import org.apache.uima.ruta.RutaBlock; | |
import org.apache.uima.ruta.RutaElement; | |
import org.apache.uima.ruta.RutaModule; | |
import org.apache.uima.ruta.RutaStatement; | |
import org.apache.uima.ruta.RutaStream; | |
import org.apache.uima.ruta.ScriptApply; | |
import org.apache.uima.ruta.rule.AbstractRule; | |
import org.apache.uima.ruta.rule.AbstractRuleMatch; | |
import org.apache.uima.ruta.rule.RuleApply; | |
import org.apache.uima.ruta.rule.RutaRule; | |
import org.apache.uima.ruta.type.DebugScriptApply; | |
import org.apache.uima.ruta.verbalize.RutaVerbalizer; | |
public class DebugInfoCollectorVisitor implements RutaInferenceVisitor { | |
private boolean createDebugInfo; | |
private List<String> ids; | |
private DebugInfoFactory debugFactory; | |
private boolean withMatches; | |
private ScriptApply rootApply; | |
private Map<RutaStatement, Stack<ScriptApply>> applies; | |
private Stack<RutaElement> callStack; | |
public DebugInfoCollectorVisitor(boolean createDebugInfo, boolean withMatches, List<String> ids, | |
RutaVerbalizer verbalizer) { | |
super(); | |
this.createDebugInfo = createDebugInfo; | |
this.withMatches = withMatches; | |
this.ids = ids; | |
debugFactory = new DebugInfoFactory(verbalizer); | |
applies = new HashMap<RutaStatement, Stack<ScriptApply>>(); | |
callStack = new Stack<RutaElement>(); | |
} | |
public DebugInfoCollectorVisitor(boolean createDebugInfo) { | |
super(); | |
this.createDebugInfo = createDebugInfo; | |
this.ids = new ArrayList<String>(); | |
} | |
public boolean isCreateDebugInfo() { | |
return createDebugInfo; | |
} | |
public boolean createDebugInfo(RutaRule rule) { | |
return createDebugInfo || ids.contains("" + rule.getId()); | |
} | |
public void beginVisit(RutaElement element, ScriptApply result) { | |
if (element instanceof RutaStatement) { | |
callStack.push(element); | |
RutaStatement stmt = (RutaStatement) element; | |
Stack<ScriptApply> stack = applies.get(stmt); | |
if (stack == null) { | |
stack = new Stack<ScriptApply>(); | |
applies.put(stmt, stack); | |
} | |
stack.push(result); | |
applies.put(stmt, stack); | |
if (result instanceof RuleApply) { | |
RuleApply ra = (RuleApply) result; | |
ra.setAcceptMatches(ra.isAcceptMatches() || withMatches); | |
} | |
} | |
} | |
public void endVisit(RutaElement element, ScriptApply result) { | |
// TODO create UIMA stuff here not later -> save memory! | |
if (element instanceof RutaStatement) { | |
RutaStatement stmt = (RutaStatement) element; | |
RutaBlock parent = stmt.getParent(); | |
Stack<ScriptApply> stack = applies.get(stmt); | |
if (stack == null) { | |
stack = new Stack<ScriptApply>(); | |
applies.put(stmt, stack); | |
} | |
// replace | |
if (!stack.isEmpty()) { | |
stack.pop(); | |
} | |
stack.push(result); | |
applies.put(stmt, stack); | |
if (parent != null) { | |
Stack<ScriptApply> parentStack = applies.get(parent); | |
if (parentStack != null && !parentStack.isEmpty()) { | |
ScriptApply parentApply = parentStack.peek(); | |
if (parentApply instanceof BlockApply) { | |
BlockApply blockApply = (BlockApply) parentApply; | |
if (element instanceof RutaRule && parent.getRule().equals(element) | |
&& result instanceof RuleApply) { | |
blockApply.setRuleApply((RuleApply) result); | |
// } else { | |
// blockApply.add(result); | |
// } | |
} else if (stack.size() == 1) { | |
if (callStack.size() > 1) { | |
// TODO hotfixed | |
RutaElement tme = callStack.get(callStack.size() - 2); | |
if (tme.equals(parent) | |
// || tme.equals(element) | |
) { | |
blockApply.add(result); | |
} else { | |
// TODO too many blocks added | |
} | |
} else { | |
blockApply.add(result); | |
} | |
} else { | |
// TODO refactor !!! ... really!!!! | |
RutaElement tme = callStack.get(callStack.size() - 2); | |
if (tme.equals(parent) | |
// || tme.equals(element) | |
) { | |
blockApply.add(result); | |
} else { | |
// TODO too many blocks added | |
} | |
} | |
} | |
} | |
} | |
stack.pop(); | |
callStack.pop(); | |
} | |
if (element instanceof RutaModule) { | |
rootApply = result; | |
} | |
} | |
public void finished(RutaStream stream, List<RutaInferenceVisitor> visitors) { | |
if (createDebugInfo) { | |
Map<RutaElement, Long> timeInfo = getTimeInfo(visitors); | |
DebugScriptApply debugScriptApply = debugFactory.createDebugScriptApply(rootApply, stream, | |
false, withMatches, timeInfo); | |
debugScriptApply.addToIndexes(); | |
} | |
} | |
private Map<RutaElement, Long> getTimeInfo(List<RutaInferenceVisitor> visitors) { | |
for (RutaInferenceVisitor each : visitors) { | |
if (each instanceof TimeProfilerVisitor) { | |
return ((TimeProfilerVisitor) each).getTimeInfo(); | |
} | |
} | |
return null; | |
} | |
public void annotationAdded(AnnotationFS annotation, | |
AbstractRuleMatch<? extends AbstractRule> creator) { | |
} | |
} |