return false;
}
+ /**
+ * @since 1.0
+ */
+ @Override
+ public boolean appliesToExperiment() {
+ return false;
+ }
+
@Override
public String getHelpText() {
return new String();
</tracetype>
</module>
<module
- id="org.eclipse.linuxtools.tmf.core.tests.analysis.testother"
- name="Test other analysis"
- analysis_module="org.eclipse.tracecompass.tmf.tests.stubs.analysis.TestAnalysis2"
- automatic="true">
+ analysis_module="org.eclipse.tracecompass.tmf.tests.stubs.analysis.TestAnalysis2"
+ automatic="true"
+ id="org.eclipse.linuxtools.tmf.core.tests.analysis.testother"
+ name="Test other analysis"
+ applies_experiment="true">
<tracetype
applies="true"
class="org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfTraceStub3">
import org.eclipse.tracecompass.tmf.core.tests.shared.TmfTestTrace;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.TmfTrace;
+import org.eclipse.tracecompass.tmf.core.trace.experiment.TmfExperiment;
import org.eclipse.tracecompass.tmf.tests.stubs.analysis.TestAnalysis;
import org.eclipse.tracecompass.tmf.tests.stubs.analysis.TestAnalysis2;
import org.eclipse.tracecompass.tmf.tests.stubs.analysis.TestRequirementAnalysis;
assertTrue(fModule.appliesToTraceType(TmfTraceStub.class));
assertTrue(fModule.appliesToTraceType(TmfTraceStub2.class));
assertFalse(fModule.appliesToTraceType(TmfTraceStub3.class));
+ assertFalse(fModule.appliesToTraceType(TmfExperiment.class));
/* stub module 2 */
assertFalse(fModuleOther.appliesToTraceType(TmfTrace.class));
assertFalse(fModuleOther.appliesToTraceType(TmfTraceStub.class));
assertTrue(fModuleOther.appliesToTraceType(TmfTraceStub2.class));
assertTrue(fModuleOther.appliesToTraceType(TmfTraceStub3.class));
+ assertFalse(fModuleOther.appliesToTraceType(TmfExperiment.class));
}
/**
assertNull(exception);
}
+
+ /**
+ * Test the analysis modules with a differing result for experiments
+ */
+ @Test
+ public void testAppliesToExperiment() {
+ ITmfTrace trace1 = TmfTestTrace.A_TEST_10K.getTrace();
+ ITmfTrace trace2 = TmfTestTrace.A_TEST_10K2.getTrace();
+ ITmfTrace trace3 = TmfTestTrace.A_TEST_10K2.getTraceAsStub2();
+
+ /* Create an experiment with TmfTraceStub */
+ ITmfTrace[] tracesExp1 = { trace1, trace2 };
+ TmfExperiment exp1 = new TmfExperiment(tracesExp1[0].getEventType(), "Experiment 1", tracesExp1, TmfExperiment.DEFAULT_INDEX_PAGE_SIZE, null);
+
+ /* Create an experiment containing some TmfTraceStub2 */
+ ITmfTrace[] tracesExp2 = { trace1, trace3 };
+ TmfExperiment exp2 = new TmfExperiment(tracesExp2[0].getEventType(), "Experiment 1", tracesExp2, TmfExperiment.DEFAULT_INDEX_PAGE_SIZE, null);
+
+ try {
+
+ /* fModule should throw exception for both experiments */
+ Exception exception = null;
+ IAnalysisModule module = null;
+ try {
+ module = fModule.newModule(exp1);
+ } catch (TmfAnalysisException e) {
+ exception = e;
+ } finally {
+ if (module != null) {
+ module.dispose();
+ }
+ }
+ assertNotNull(exception);
+ assertEquals(NLS.bind(Messages.TmfAnalysisModuleHelper_AnalysisDoesNotApply, fModule.getName()), exception.getMessage());
+
+ exception = null;
+ try {
+ module = fModule.newModule(exp2);
+ } catch (TmfAnalysisException e) {
+ exception = e;
+ } finally {
+ if (module != null) {
+ module.dispose();
+ }
+ }
+ assertNotNull(exception);
+ assertEquals(NLS.bind(Messages.TmfAnalysisModuleHelper_AnalysisDoesNotApply, fModule.getName()), exception.getMessage());
+
+ /* fModuleOther should throw exception for exp1, but not exp2 */
+ exception = null;
+ try {
+ module = fModuleOther.newModule(exp1);
+ } catch (TmfAnalysisException e) {
+ exception = e;
+ } finally {
+ if (module != null) {
+ module.dispose();
+ }
+ }
+ assertNotNull(exception);
+ assertEquals(NLS.bind(Messages.TmfAnalysisModuleHelper_AnalysisDoesNotApply, fModuleOther.getName()), exception.getMessage());
+
+ exception = null;
+ try {
+ module = fModuleOther.newModule(exp2);
+ assertNotNull(module);
+ } catch (TmfAnalysisException e) {
+ exception = e;
+ } finally {
+ if (module != null) {
+ module.dispose();
+ }
+ }
+ assertNull(exception);
+
+ } finally {
+ exp2.dispose();
+ exp1.dispose();
+ }
+ }
+
/**
* Test for the initialization of parameters from the extension points
*/
return false;
}
+ @Override
+ public boolean appliesToExperiment() {
+ return false;
+ }
+
@Override
public String getHelpText() {
return "";
return Collections.EMPTY_SET;
}
}
+
}
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.tracecompass.tmf.core.analysis.TmfAbstractAnalysisModule;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfTraceStub2;
/**
@Override
public boolean canExecute(ITmfTrace trace) {
- /* This just makes sure the trace is a trace stub 2 */
- return (TmfTraceStub2.class.isAssignableFrom(trace.getClass()));
+ /* This just makes sure the trace is or contains a trace stub 2 */
+ for (ITmfTrace aTrace : TmfTraceManager.getTraceSet(trace)) {
+ if (TmfTraceStub2.class.isAssignableFrom(aTrace.getClass())) {
+ return true;
+ }
+ }
+ return false;
}
@Override
</documentation>
</annotation>
</attribute>
+ <attribute name="applies_experiment" type="boolean">
+ <annotation>
+ <documentation>
+ If true, indicate that an instance of this analysis will also be added to an experiment containing one or more trace(s) it applies to. In this case, the analysis will be run on the full experiment and the result is more than just the aggregation of each trace's analysis (default false).
+ </documentation>
+ </annotation>
+ </attribute>
</complexType>
</element>
/** Extension point attribute 'automatic' */
public static final String AUTOMATIC_ATTR = "automatic"; //$NON-NLS-1$
+ /** Extension point attribute 'applies_experiment' */
+ public static final String APPLIES_EXP_ATTR = "applies_experiment"; //$NON-NLS-1$
+
/** Extension point attribute 'icon' */
public static final String ICON_ATTR = "icon"; //$NON-NLS-1$
*/
Iterable<Class<? extends ITmfTrace>> getValidTraceTypes();
+ /**
+ * Determine if an analysis should be run on an experiment if it applies to
+ * at least one of its traces. It means that an instance of the analysis
+ * module will be created specifically for the experiment and the result
+ * will be more than a simple aggregation of the results of each trace's
+ * module. This method does not actually do the check, it just returns
+ * whether it should apply.
+ *
+ * @return whether this analysis should be run on an experiment
+ * @since 1.0
+ */
+ boolean appliesToExperiment();
+
// ---------------------------------------
// Functionalities
// ---------------------------------------
*
* This map is read-only
*
+ * TODO: This method is only used to populate the project view in the UI. It
+ * should be deprecated eventually, after some UI rework, so that the trace
+ * type does not drive whether the analysis module applies or not to a
+ * trace, but rather the content of the trace or experiment (once it is
+ * opened)
+ *
* @param traceclass
* The trace class to get modules for
* @return The map of available {@link IAnalysisModuleHelper}
import org.eclipse.tracecompass.tmf.core.project.model.TmfTraceType;
import org.eclipse.tracecompass.tmf.core.project.model.TraceTypeHelper;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
+import org.eclipse.tracecompass.tmf.core.trace.experiment.TmfExperiment;
import org.osgi.framework.Bundle;
/**
return Boolean.parseBoolean(fCe.getAttribute(TmfAnalysisModuleSourceConfigElement.AUTOMATIC_ATTR));
}
+ /**
+ * @since 1.0
+ */
+ @Override
+ public boolean appliesToExperiment() {
+ return Boolean.parseBoolean(fCe.getAttribute(TmfAnalysisModuleSourceConfigElement.APPLIES_EXP_ATTR));
+ }
+
@Override
public String getHelpText() {
/*
if (classApplies) {
applies |= applyclass.isAssignableFrom(traceclass);
} else {
- /* If the trace type does not apply, reset the applies variable to false */
+ /*
+ * If the trace type does not apply, reset the applies
+ * variable to false
+ */
if (applyclass.isAssignableFrom(traceclass)) {
applies = false;
}
}
- } catch (ClassNotFoundException e) {
- Activator.logError("Error in applies to trace", e); //$NON-NLS-1$
- } catch (InvalidRegistryObjectException e) {
+ } catch (ClassNotFoundException | InvalidRegistryObjectException e) {
Activator.logError("Error in applies to trace", e); //$NON-NLS-1$
}
}
@Override
public IAnalysisModule newModule(ITmfTrace trace) throws TmfAnalysisException {
+ /* Check if it applies to trace itself */
+ boolean applies = appliesToTraceType(trace.getClass());
+ /*
+ * If the trace is an experiment, check if this module would apply to an
+ * experiment should it apply to one of its traces.
+ */
+ if (!applies && (trace instanceof TmfExperiment) && appliesToExperiment()) {
+ for (ITmfTrace expTrace : TmfTraceManager.getTraceSet(trace)) {
+ if (appliesToTraceType(expTrace.getClass())) {
+ applies = true;
+ break;
+ }
+ }
+ }
+
/* Check that analysis can be executed */
- if (!appliesToTraceType(trace.getClass())) {
+ if (!applies) {
throw new TmfAnalysisException(NLS.bind(Messages.TmfAnalysisModuleHelper_AnalysisDoesNotApply, getName()));
}
import org.eclipse.tracecompass.tmf.core.trace.location.ITmfLocation;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Multimap;
/**
* Abstract implementation of ITmfTrace.
protected IStatus executeAnalysis() {
MultiStatus status = new MultiStatus(Activator.PLUGIN_ID, IStatus.OK, null, null);
- Class<? extends TmfTrace> className = checkNotNull(this.getClass());
- Map<String, IAnalysisModuleHelper> modules = TmfAnalysisManager.getAnalysisModules(className);
+ Multimap<String, IAnalysisModuleHelper> modules = TmfAnalysisManager.getAnalysisModules();
for (IAnalysisModuleHelper helper : modules.values()) {
try {
IAnalysisModule module = helper.newModule(this);
import org.eclipse.tracecompass.internal.tmf.ui.Activator;
import org.eclipse.tracecompass.internal.tmf.ui.editors.ITmfEventsEditorConstants;
import org.eclipse.tracecompass.tmf.core.TmfCommonConstants;
+import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModuleHelper;
+import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisManager;
import org.eclipse.tracecompass.tmf.core.project.model.TmfTraceType;
import org.eclipse.tracecompass.tmf.core.project.model.TraceTypeHelper;
+import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.experiment.TmfExperiment;
import org.eclipse.tracecompass.tmf.ui.editors.TmfEventsEditor;
import org.eclipse.tracecompass.tmf.ui.properties.ReadOnlyTextPropertyDescriptor;
/* Update the analysis under this experiment */
super.refreshChildren();
+
+ /*
+ * If the experiment is opened, add any analysis that was not added by
+ * the parent if it is available with the experiment
+ */
+ ITmfTrace experiment = getTrace();
+ if (experiment == null) {
+ return;
+ }
+ Map<String, TmfAnalysisElement> analysisMap = new HashMap<>();
+ for (TmfAnalysisElement analysis : getAvailableAnalysis()) {
+ analysisMap.put(analysis.getAnalysisId(), analysis);
+ }
+ for (IAnalysisModuleHelper module : TmfAnalysisManager.getAnalysisModules().values()) {
+ if (!analysisMap.containsKey(module.getId()) && module.appliesToExperiment() && (experiment.getAnalysisModule(module.getId()) != null)) {
+ IFolder newresource = ResourcesPlugin.getWorkspace().getRoot().getFolder(fResource.getFullPath().append(module.getId()));
+ TmfAnalysisElement analysis = new TmfAnalysisElement(module.getName(), newresource, this, module);
+ analysis.refreshChildren();
+ analysisMap.put(module.getId(), analysis);
+ }
+ }
}
private List<IResource> getTraceResources() {
projects / deliverable / tracecompass.git / commitdiff
