package org.signalml.plugin.newartifact.logic.mgr;
import static org.signalml.plugin.i18n.PluginI18n._;
import static org.signalml.plugin.i18n.PluginI18n._R;
import java.io.File;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import org.signalml.method.MethodExecutionTracker;
import org.signalml.plugin.data.logic.PluginComputationMgrStepResult;
import org.signalml.plugin.method.logic.AbstractPluginComputationMgrStepTrackerProxy;
import org.signalml.plugin.method.logic.IPluginComputationMgrStep;
import org.signalml.plugin.method.logic.PluginCheckedThreadGroup;
import org.signalml.plugin.method.logic.PluginComputationMgr;
import org.signalml.plugin.newartifact.data.NewArtifactResult;
import org.signalml.plugin.newartifact.data.mgr.NewArtifactMgrData;
import org.signalml.plugin.newartifact.data.mgr.NewArtifactMgrStepData;
import org.signalml.plugin.newartifact.data.mgr.NewArtifactMgrStepResult;
import org.signalml.plugin.newartifact.method.NewArtifactMethod;
public class NewArtifactComputationMgr extends
PluginComputationMgr<NewArtifactMgrData, NewArtifactResult> {
protected static final Logger logger = Logger
.getLogger(NewArtifactMethod.class);
private class TrackerProxy
extends
AbstractPluginComputationMgrStepTrackerProxy<NewArtifactComputationProgressPhase> {
public TrackerProxy(PluginCheckedThreadGroup threadGroup,
MethodExecutionTracker tracker) {
super(threadGroup, tracker);
}
@Override
public void advance(IPluginComputationMgrStep step, int tick) {
synchronized (this.tracker) {
this.tracker.tick(0, tick);
}
}
@Override
public void setProgressPhase(NewArtifactComputationProgressPhase phase,
Object... arguments) {
if (this.phase == NewArtifactComputationProgressPhase.ABORT_PHASE) {
return;
}
super.setProgressPhase(phase, arguments);
}
@Override
public boolean isRequestingAbort() {
boolean result = super.isRequestingAbort();
if (result) {
this.setProgressPhase(NewArtifactComputationProgressPhase.ABORT_PHASE);
}
return result;
}
@Override
protected String getMessageForPhase(
NewArtifactComputationProgressPhase phase, Object... arguments) {
switch (phase) {
case PREPROCESS_PREPARE_PHASE:
return _("Preparing");
case SOURCE_FILE_INITIAL_READ_PHASE:
return _("Reading source data");
case INTERMEDIATE_COMPUTATION_PHASE:
return _R("Computing intermediate data (block {0} of {1})",
arguments);
case TAGGER_PREPARE_PHASE:
return _("Preparing tagger");
case TAGGING_PHASE:
return _("Tagging artifacts");
case TAG_MERGING_PHASE:
return _("Merging tag files");
case ABORT_PHASE:
return _("Aborting");
default:
return null;
}
}
}
private List<IPluginComputationMgrStep> steps;
private TrackerProxy trackerProxy;
@Override
protected Collection<IPluginComputationMgrStep> prepareStepChain() {
this.steps = new LinkedList<IPluginComputationMgrStep>();
this.trackerProxy = new TrackerProxy(this.getThreadGroup(),
this.tracker);
NewArtifactMgrStepData stepData = new NewArtifactMgrStepData(
data.artifactData, data.constants,
new NewArtifactIntermediateFilesPathConstructor(
data.artifactData), this.trackerProxy,
this.getThreadFactory());
this.steps.add(new NewArtifactMgrPreprocessStep(stepData));
this.steps.add(new NewArtifactMgrTagStep(stepData));
return this.steps;
}
@Override
protected void initializeRun(Map<IPluginComputationMgrStep, Integer> tickMap) {
for (Map.Entry<IPluginComputationMgrStep, Integer> v : tickMap
.entrySet()) {
this.trackerProxy.setTickerLimit(v.getKey(), v.getValue());
}
}
@Override
protected NewArtifactResult prepareComputationResult() {
PluginComputationMgrStepResult lastStepResult = this.stepResults
.get(this.steps.get(this.steps.size() - 1));
if (lastStepResult == null) {
return null;
}
NewArtifactMgrStepResult castedLastStepResult;
try {
castedLastStepResult = (NewArtifactMgrStepResult) lastStepResult;
} catch (ClassCastException e) {
logger.error("Unexpected step result class");
return null;
}
NewArtifactResult result = new NewArtifactResult();
result.setTagFile(new File(castedLastStepResult.resultTagPath));
return result;
}
}