import org.eclipse.tracecompass.tmf.core.statistics.TmfStatisticsModule;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
import org.eclipse.tracecompass.tmf.ui.viewers.xycharts.barcharts.TmfBarChartViewer;
import org.swtchart.Chart;
import org.swtchart.IAxis;
for (ITmfTrace trace : TmfTraceManager.getTraceSet(getTrace())) {
/* Retrieve the statistics object */
final TmfStatisticsModule statsMod =
- trace.getAnalysisModuleOfClass(TmfStatisticsModule.class, TmfStatisticsModule.ID);
+ TmfTraceUtils.getAnalysisModuleOfClass(trace, TmfStatisticsModule.class, TmfStatisticsModule.ID);
if (statsMod == null) {
/* No statistics module available for this trace */
continue;
import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;
import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
/**
* This analysis module computes the CPU usage of a system from a kernel trace.
* This analysis depends on the LTTng kernel analysis, so it's added to
* dependent modules.
*/
- Iterable<LttngKernelAnalysis> kernelModules = trace.getAnalysisModulesOfClass(LttngKernelAnalysis.class);
- if (kernelModules.iterator().hasNext()) {
- modules.add(kernelModules.iterator().next());
+ Iterable<LttngKernelAnalysis> kernelModules = TmfTraceUtils.getAnalysisModulesOfClass(trace, LttngKernelAnalysis.class);
+ for (LttngKernelAnalysis kernelModule : kernelModules) {
+ /* Only add the first one we find, if there is one */
+ modules.add(kernelModule);
+ break;
}
return modules;
}
import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
import org.eclipse.tracecompass.tmf.ui.viewers.tree.AbstractTmfTreeViewer;
import org.eclipse.tracecompass.tmf.ui.viewers.tree.ITmfTreeColumnDataProvider;
import org.eclipse.tracecompass.tmf.ui.viewers.tree.ITmfTreeViewerEntry;
@Override
public void initializeDataSource() {
- fModule = getTrace().getAnalysisModuleOfClass(LttngKernelCpuUsageAnalysis.class, LttngKernelCpuUsageAnalysis.ID);
+ fModule = TmfTraceUtils.getAnalysisModuleOfClass(getTrace(), LttngKernelCpuUsageAnalysis.class, LttngKernelCpuUsageAnalysis.ID);
if (fModule == null) {
return;
}
import org.eclipse.tracecompass.lttng2.kernel.core.analysis.cpuusage.LttngKernelCpuUsageAnalysis;
import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
import org.eclipse.tracecompass.statesystem.core.exceptions.StateValueTypeException;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
import org.eclipse.tracecompass.tmf.ui.viewers.xycharts.linecharts.TmfCommonXLineChartViewer;
/**
@Override
protected void initializeDataSource() {
if (getTrace() != null) {
- fModule = getTrace().getAnalysisModuleOfClass(LttngKernelCpuUsageAnalysis.class, LttngKernelCpuUsageAnalysis.ID);
+ fModule = TmfTraceUtils.getAnalysisModuleOfClass(getTrace(), LttngKernelCpuUsageAnalysis.class, LttngKernelCpuUsageAnalysis.ID);
if (fModule == null) {
return;
}
import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException;
import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
import org.eclipse.tracecompass.tmf.ui.viewers.xycharts.linecharts.TmfCommonXLineChartViewer;
/**
@Override
protected void initializeDataSource() {
if (getTrace() != null) {
- fModule = getTrace().getAnalysisModuleOfClass(TmfStateSystemAnalysisModule.class, UstMemoryAnalysisModule.ID);
+ fModule = TmfTraceUtils.getAnalysisModuleOfClass(getTrace(), TmfStateSystemAnalysisModule.class, UstMemoryAnalysisModule.ID);
if (fModule == null) {
return;
}
import org.eclipse.tracecompass.tmf.core.statesystem.ITmfAnalysisModuleWithStateSystems;
import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
import org.eclipse.tracecompass.tmf.ui.viewers.xycharts.linecharts.TmfCommonXLineChartViewer;
import org.w3c.dom.Element;
/*
* No analysis specified, take all state system analysis modules
*/
- for (ITmfAnalysisModuleWithStateSystems module : trace.getAnalysisModulesOfClass(ITmfAnalysisModuleWithStateSystems.class)) {
+ for (ITmfAnalysisModuleWithStateSystems module : TmfTraceUtils.getAnalysisModulesOfClass(trace, ITmfAnalysisModuleWithStateSystems.class)) {
stateSystemModules.add(module);
}
} else {
for (String moduleId : analysisIds) {
- ITmfAnalysisModuleWithStateSystems module = trace.getAnalysisModuleOfClass(ITmfAnalysisModuleWithStateSystems.class, moduleId);
+ ITmfAnalysisModuleWithStateSystems module = TmfTraceUtils.getAnalysisModuleOfClass(trace, ITmfAnalysisModuleWithStateSystems.class, moduleId);
if (module != null) {
stateSystemModules.add(module);
}
import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
import org.eclipse.tracecompass.tmf.ui.views.timegraph.AbstractTimeGraphView;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphPresentationProvider2;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.ILinkEvent;
/*
* No analysis specified, take all state system analysis modules
*/
- for (ITmfAnalysisModuleWithStateSystems module : aTrace.getAnalysisModulesOfClass(ITmfAnalysisModuleWithStateSystems.class)) {
+ for (ITmfAnalysisModuleWithStateSystems module : TmfTraceUtils.getAnalysisModulesOfClass(aTrace, ITmfAnalysisModuleWithStateSystems.class)) {
stateSystemModules.add(module);
}
} else {
for (String moduleId : analysisIds) {
- ITmfAnalysisModuleWithStateSystems module = aTrace.getAnalysisModuleOfClass(ITmfAnalysisModuleWithStateSystems.class, moduleId);
+ ITmfAnalysisModuleWithStateSystems module = TmfTraceUtils.getAnalysisModuleOfClass(aTrace, ITmfAnalysisModuleWithStateSystems.class, moduleId);
if (module != null) {
stateSystemModules.add(module);
}
TmfExperimentTest.class,
TmfExperimentUtilsTest.class,
TmfMultiTraceExperimentTest.class,
- TmfTraceTest.class
+ TmfTraceTest.class,
+ TmfTraceUtilsTest.class
})
public class AllTests {}
\ No newline at end of file
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
import org.eclipse.tracecompass.tmf.core.trace.experiment.TmfExperiment;
import org.eclipse.tracecompass.tmf.core.trace.location.ITmfLocation;
import org.eclipse.tracecompass.tmf.core.trace.location.TmfLongLocation;
/* Open the experiment, the modules should be populated */
fExperiment.traceOpened(new TmfTraceOpenedSignal(this, fExperiment, null));
modules = fExperiment.getAnalysisModules();
- Iterable<TestExperimentAnalysis> testModules = fExperiment.getAnalysisModulesOfClass(TestExperimentAnalysis.class);
+ Iterable<TestExperimentAnalysis> testModules = TmfTraceUtils.getAnalysisModulesOfClass(fExperiment, TestExperimentAnalysis.class);
assertTrue(modules.iterator().hasNext());
assertTrue(testModules.iterator().hasNext());
}
import org.eclipse.tracecompass.tmf.core.component.ITmfEventProvider;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
-import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest.ExecutionType;
+import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalManager;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
import org.eclipse.tracecompass.tmf.core.tests.TmfCoreTestPlugin;
// ------------------------------------------------------------------------
@Test
- public void testGetModulesByClass() {
+ public void testGetModules() {
/* There should not be any modules at this point */
Iterable<IAnalysisModule> modules = fTrace.getAnalysisModules();
assertFalse(modules.iterator().hasNext());
fTrace.traceOpened(new TmfTraceOpenedSignal(this, fTrace, null));
modules = fTrace.getAnalysisModules();
- Iterable<TestAnalysis> testModules = fTrace.getAnalysisModulesOfClass(TestAnalysis.class);
assertTrue(modules.iterator().hasNext());
- assertTrue(testModules.iterator().hasNext());
/*
* Make sure all modules of type TestAnalysis are returned in the second
* call
*/
+ int count = 0;
for (IAnalysisModule module : modules) {
if (module instanceof TestAnalysis) {
+ count++;
IAnalysisModule otherModule = fTrace.getAnalysisModule(module.getId());
assertNotNull(otherModule);
- assertTrue(otherModule.equals(module));
+ assertEquals(otherModule, module);
}
}
-
+ /*
+ * FIXME: The exact count depends on the context the test is run (full
+ * test suite or this file only), but there must be at least 2 modules
+ */
+ assertTrue(count >= 2);
}
// ------------------------------------------------------------------------
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2014 Ericsson
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v1.0 which
+ * accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Alexandre Montplaisir - Initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.tmf.core.tests.trace;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.net.URL;
+
+import org.eclipse.core.runtime.FileLocator;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
+import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSignalManager;
+import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
+import org.eclipse.tracecompass.tmf.core.tests.TmfCoreTestPlugin;
+import org.eclipse.tracecompass.tmf.core.tests.analysis.AnalysisManagerTest;
+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.TmfTraceUtils;
+import org.eclipse.tracecompass.tmf.tests.stubs.analysis.TestAnalysis;
+import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfTraceStub;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Test suite for {@link TmfTraceUtils}
+ */
+public class TmfTraceUtilsTest {
+
+ private static final TmfTestTrace TEST_TRACE = TmfTestTrace.A_TEST_10K;
+
+ private TmfTrace fTrace;
+
+ // ------------------------------------------------------------------------
+ // Housekeeping
+ // ------------------------------------------------------------------------
+
+ /**
+ * Test setup
+ */
+ @Before
+ public void setUp() {
+ try {
+ final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
+ final File test = new File(FileLocator.toFileURL(location).toURI());
+ fTrace = new TmfTraceStub(test.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, false, null);
+ TmfSignalManager.deregister(fTrace);
+ fTrace.indexTrace(true);
+ } catch (final TmfTraceException | URISyntaxException | IOException e) {
+ fail(e.getMessage());
+ }
+ }
+
+ /**
+ * Test cleanup
+ */
+ @After
+ public void tearDown() {
+ fTrace.dispose();
+ fTrace = null;
+ }
+
+ // ------------------------------------------------------------------------
+ // Test methods
+ // ------------------------------------------------------------------------
+
+ /**
+ * Test the {@link TmfTraceUtils#getAnalysisModuleOfClass} method.
+ */
+ @Test
+ public void testGetModulesByClass() {
+ /* Open the trace, the modules should be populated */
+ fTrace.traceOpened(new TmfTraceOpenedSignal(this, fTrace, null));
+
+ Iterable<TestAnalysis> testModules = TmfTraceUtils.getAnalysisModulesOfClass(fTrace, TestAnalysis.class);
+ assertTrue(testModules.iterator().hasNext());
+
+ int count = 0;
+ for (TestAnalysis module : testModules) {
+ assertNotNull(module);
+ count++;
+ }
+ /*
+ * FIXME: The exact count depends on the context the test is run (full
+ * test suite or this file only), but there must be at least 2 modules
+ */
+ assertTrue(count >= 2);
+
+ TestAnalysis module = TmfTraceUtils.getAnalysisModuleOfClass(fTrace, TestAnalysis.class, AnalysisManagerTest.MODULE_PARAM);
+ assertNotNull(module);
+ IAnalysisModule traceModule = fTrace.getAnalysisModule(AnalysisManagerTest.MODULE_PARAM);
+ assertNotNull(traceModule);
+ assertEquals(module, traceModule);
+
+ }
+}
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTraceCompleteness;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
import org.eclipse.tracecompass.tmf.core.trace.experiment.TmfExperiment;
/**
*/
public static @Nullable ITmfStateSystem getStateSystem(ITmfTrace trace, String moduleId) {
TmfStateSystemAnalysisModule module =
- trace.getAnalysisModuleOfClass(TmfStateSystemAnalysisModule.class, moduleId);
+ TmfTraceUtils.getAnalysisModuleOfClass(trace, TmfStateSystemAnalysisModule.class, moduleId);
if (module != null) {
IStatus status = module.schedule();
if (status.isOK()) {
* The analysis module ID
* @return The {@link IAnalysisModule} object, or null if an analysis with
* the given ID does no exist.
- * @since 3.0
*/
- @Nullable
- IAnalysisModule getAnalysisModule(String id);
+ @Nullable IAnalysisModule getAnalysisModule(String id);
/**
* Get a list of all analysis modules currently available for this trace.
*
* @return An iterable view of the analysis modules
- * @since 3.0
- */
- @NonNull
- Iterable<IAnalysisModule> getAnalysisModules();
-
- /**
- * Get an analysis module belonging to this trace, with the specified ID and
- * class.
- *
- * @param moduleClass
- * Returned modules must extend this class
- * @param id
- * The ID of the analysis module
- * @return The analysis module with specified class and ID, or null if no
- * such module exists.
- * @since 3.0
- */
- @Nullable
- <T extends IAnalysisModule> T getAnalysisModuleOfClass(Class<T> moduleClass, String id);
-
- /**
- * Return the analysis modules that are of a given class. Module are already
- * casted to the requested class.
- *
- * @param moduleClass
- * Returned modules must extend this class
- * @return List of modules of class moduleClass
- * @since 3.0
*/
- @NonNull
- <T> Iterable<T> getAnalysisModulesOfClass(Class<T> moduleClass);
+ @NonNull Iterable<IAnalysisModule> getAnalysisModules();
// ------------------------------------------------------------------------
// Aspect getters
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Map;
-import java.util.Map.Entry;
import java.util.Set;
import org.eclipse.core.resources.IResource;
}
}
- /**
- * @since 3.0
- */
- @Override
- public <T extends IAnalysisModule> T getAnalysisModuleOfClass(Class<T> moduleClass, String id) {
- Iterable<T> modules = getAnalysisModulesOfClass(moduleClass);
- for (T module : modules) {
- if (id.equals(module.getId())) {
- return module;
- }
- }
- return null;
- }
-
- /**
- * @since 3.0
- */
- @Override
- public <T> Iterable<T> getAnalysisModulesOfClass(Class<T> moduleClass) {
- Set<T> modules = new HashSet<>();
- synchronized (fAnalysisModules) {
- for (Entry<String, IAnalysisModule> entry : fAnalysisModules.entrySet()) {
- if (moduleClass.isAssignableFrom(entry.getValue().getClass())) {
- modules.add(moduleClass.cast(entry.getValue()));
- }
- }
- }
- return modules;
- }
-
@Override
public Iterable<ITmfEventAspect> getEventAspects() {
/* By default we provide only the base aspects valid for all trace types */
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2014 Ericsson
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v1.0 which
+ * accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Alexandre Montplaisir - Initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.tmf.core.trace;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
+
+/**
+ * Utility methods for ITmfTrace's.
+ *
+ * @author Alexandre Montplaisir
+ */
+public final class TmfTraceUtils {
+
+ private TmfTraceUtils() {}
+
+ /**
+ * Get an analysis module belonging to this trace, with the specified ID and
+ * class.
+ *
+ * @param trace
+ * The trace for which you want the modules
+ * @param moduleClass
+ * Returned modules must extend this class
+ * @param id
+ * The ID of the analysis module
+ * @return The analysis module with specified class and ID, or null if no
+ * such module exists.
+ */
+ public static @Nullable <T extends IAnalysisModule> T getAnalysisModuleOfClass(ITmfTrace trace,
+ Class<T> moduleClass, String id) {
+ Iterable<T> modules = getAnalysisModulesOfClass(trace, moduleClass);
+ for (T module : modules) {
+ if (id.equals(module.getId())) {
+ return module;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Return the analysis modules that are of a given class. Module will be
+ * casted to the requested class.
+ *
+ * @param trace
+ * The trace for which you want the modules
+ * @param moduleClass
+ * Returned modules must extend this class
+ * @return List of modules of class moduleClass
+ */
+ public static @NonNull <T> Iterable<T> getAnalysisModulesOfClass(ITmfTrace trace, Class<T> moduleClass) {
+ Iterable<IAnalysisModule> analysisModules = trace.getAnalysisModules();
+ Set<T> modules = new HashSet<>();
+ for (IAnalysisModule module : analysisModules) {
+ if (moduleClass.isAssignableFrom(module.getClass())) {
+ modules.add(moduleClass.cast(module));
+ }
+ }
+ return modules;
+ }
+}
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
/**
* This utility class contains some utility methods to retrieve specific traces
*/
public static @Nullable <T extends IAnalysisModule> T getAnalysisModuleOfClassForHost(TmfExperiment experiment, String hostId, Class<T> moduleClass) {
for (ITmfTrace trace : getTracesFromHost(experiment, hostId)) {
- for (T module : trace.getAnalysisModulesOfClass(moduleClass)) {
+ for (T module : TmfTraceUtils.getAnalysisModulesOfClass(trace, moduleClass)) {
return module;
}
}
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
import org.eclipse.tracecompass.tmf.ui.project.model.TraceUtils;
import org.eclipse.tracecompass.tmf.ui.views.TmfView;
import org.eclipse.tracecompass.tmf.ui.views.filter.FilterManager;
if (trace == null || (!(trace instanceof PcapTrace))) {
return;
}
- StreamListAnalysis analysis = trace.getAnalysisModuleOfClass(StreamListAnalysis.class, StreamListAnalysis.ID);
+ StreamListAnalysis analysis = TmfTraceUtils.getAnalysisModuleOfClass(trace, StreamListAnalysis.class, StreamListAnalysis.ID);
if (analysis == null) {
return;
}
return;
}
- StreamListAnalysis analysis = trace.getAnalysisModuleOfClass(StreamListAnalysis.class, StreamListAnalysis.ID);
+ StreamListAnalysis analysis = TmfTraceUtils.getAnalysisModuleOfClass(trace, StreamListAnalysis.class, StreamListAnalysis.ID);
if (analysis == null) {
return;
}
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
import org.eclipse.tracecompass.tmf.core.trace.experiment.TmfExperiment;
import org.eclipse.tracecompass.tmf.ui.TmfUiRefreshHandler;
import org.eclipse.tracecompass.tmf.ui.viewers.TmfViewer;
}
/* Retrieve the statistics object */
- final TmfStatisticsModule statsMod = aTrace.getAnalysisModuleOfClass(TmfStatisticsModule.class, TmfStatisticsModule.ID);
+ final TmfStatisticsModule statsMod = TmfTraceUtils.getAnalysisModuleOfClass(aTrace, TmfStatisticsModule.class, TmfStatisticsModule.ID);
if (statsMod == null) {
/* No statistics module available for this trace */
continue;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestampDelta;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
import org.eclipse.tracecompass.tmf.ui.editors.ITmfTraceEditor;
import org.eclipse.tracecompass.tmf.ui.views.TmfView;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphContentProvider;
* will search using the analysis type.
*/
Iterable<AbstractCallStackAnalysis> modules =
- trace.getAnalysisModulesOfClass(AbstractCallStackAnalysis.class);
+ TmfTraceUtils.getAnalysisModulesOfClass(trace, AbstractCallStackAnalysis.class);
Iterator<AbstractCallStackAnalysis> it = modules.iterator();
if (!it.hasNext()) {
/* This trace does not provide a call-stack analysis */
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
import org.eclipse.tracecompass.tmf.ui.viewers.tree.AbstractTmfTreeViewer;
import org.eclipse.tracecompass.tmf.ui.viewers.tree.ITmfTreeColumnDataProvider;
import org.eclipse.tracecompass.tmf.ui.viewers.tree.ITmfTreeViewerEntry;
private static TmfTreeViewerEntry createTraceEntry(ITmfTrace trace) {
TmfTreeViewerEntry traceEntry = new TmfTreeViewerEntry(trace.getName());
- Iterable<ITmfAnalysisModuleWithStateSystems> modules = trace.getAnalysisModulesOfClass(ITmfAnalysisModuleWithStateSystems.class);
+ Iterable<ITmfAnalysisModuleWithStateSystems> modules = TmfTraceUtils.getAnalysisModulesOfClass(trace, ITmfAnalysisModuleWithStateSystems.class);
for (ITmfAnalysisModuleWithStateSystems module : modules) {
/* Just schedule the module, the data will be filled when available */
module.schedule();
projects / deliverable / tracecompass.git / commitdiff
