return retMap;
}
ControlFlowEntry entry = (ControlFlowEntry) event.getEntry();
- LttngKernelAnalysisModule module = entry.getTrace().getAnalysisModules(LttngKernelAnalysisModule.class).get(LttngKernelAnalysisModule.ID);
+ LttngKernelAnalysisModule module = entry.getTrace().getAnalysisModuleOfClass(LttngKernelAnalysisModule.class, LttngKernelAnalysisModule.ID);
if (module == null) {
return retMap;
}
return;
}
ControlFlowEntry entry = (ControlFlowEntry) event.getEntry();
- LttngKernelAnalysisModule module = entry.getTrace().getAnalysisModules(LttngKernelAnalysisModule.class).get(LttngKernelAnalysisModule.ID);
+ LttngKernelAnalysisModule module = entry.getTrace().getAnalysisModuleOfClass(LttngKernelAnalysisModule.class, LttngKernelAnalysisModule.ID);
if (module == null) {
return;
}
@Override
protected void buildEventList(final ITmfTrace trace, ITmfTrace parentTrace, IProgressMonitor monitor) {
- LttngKernelAnalysisModule module = trace.getAnalysisModules(LttngKernelAnalysisModule.class).get(LttngKernelAnalysisModule.ID);
+ LttngKernelAnalysisModule module = trace.getAnalysisModuleOfClass(LttngKernelAnalysisModule.class, LttngKernelAnalysisModule.ID);
if (module == null) {
return;
}
private void buildStatusEvents(ITmfTrace trace, ControlFlowEntry entry, IProgressMonitor monitor, long start, long end) {
if (start < entry.getEndTime() && end > entry.getStartTime()) {
- LttngKernelAnalysisModule module = entry.getTrace().getAnalysisModules(LttngKernelAnalysisModule.class).get(LttngKernelAnalysisModule.ID);
+ LttngKernelAnalysisModule module = entry.getTrace().getAnalysisModuleOfClass(LttngKernelAnalysisModule.class, LttngKernelAnalysisModule.ID);
if (module == null) {
return;
}
if (realEnd <= realStart) {
return null;
}
- LttngKernelAnalysisModule module = entry.getTrace().getAnalysisModules(LttngKernelAnalysisModule.class).get(LttngKernelAnalysisModule.ID);
+ LttngKernelAnalysisModule module = entry.getTrace().getAnalysisModuleOfClass(LttngKernelAnalysisModule.class, LttngKernelAnalysisModule.ID);
if (module == null) {
return null;
}
if (thread > 0) {
break;
}
- LttngKernelAnalysisModule module = trace.getAnalysisModules(LttngKernelAnalysisModule.class).get(LttngKernelAnalysisModule.ID);
+ LttngKernelAnalysisModule module = trace.getAnalysisModuleOfClass(LttngKernelAnalysisModule.class, LttngKernelAnalysisModule.ID);
if (module == null) {
continue;
}
return list;
}
for (ITmfTrace trace : traces) {
- LttngKernelAnalysisModule module = trace.getAnalysisModules(LttngKernelAnalysisModule.class).get(LttngKernelAnalysisModule.ID);
+ LttngKernelAnalysisModule module = trace.getAnalysisModuleOfClass(LttngKernelAnalysisModule.class, LttngKernelAnalysisModule.ID);
if (module == null) {
continue;
}
ResourcesEntry entry = (ResourcesEntry) event.getEntry();
if (tcEvent.hasValue()) {
- LttngKernelAnalysisModule module = entry.getTrace().getAnalysisModules(LttngKernelAnalysisModule.class).get(LttngKernelAnalysisModule.ID);
+ LttngKernelAnalysisModule module = entry.getTrace().getAnalysisModuleOfClass(LttngKernelAnalysisModule.class, LttngKernelAnalysisModule.ID);
if (module == null) {
return retMap;
}
return;
}
- LttngKernelAnalysisModule module = entry.getTrace().getAnalysisModules(LttngKernelAnalysisModule.class).get(LttngKernelAnalysisModule.ID);
+ LttngKernelAnalysisModule module = entry.getTrace().getAnalysisModuleOfClass(LttngKernelAnalysisModule.class, LttngKernelAnalysisModule.ID);
if (module == null) {
return;
}
@Override
protected void buildEventList(ITmfTrace trace, ITmfTrace parentTrace, IProgressMonitor monitor) {
- LttngKernelAnalysisModule module = trace.getAnalysisModules(LttngKernelAnalysisModule.class).get(LttngKernelAnalysisModule.ID);
+ LttngKernelAnalysisModule module = trace.getAnalysisModuleOfClass(LttngKernelAnalysisModule.class, LttngKernelAnalysisModule.ID);
if (module == null) {
return;
}
long startTime, long endTime, long resolution,
IProgressMonitor monitor) {
ResourcesEntry resourcesEntry = (ResourcesEntry) entry;
- LttngKernelAnalysisModule module = resourcesEntry.getTrace().getAnalysisModules(LttngKernelAnalysisModule.class).get(LttngKernelAnalysisModule.ID);
+ LttngKernelAnalysisModule module = resourcesEntry.getTrace().getAnalysisModuleOfClass(LttngKernelAnalysisModule.class, LttngKernelAnalysisModule.ID);
if (module == null) {
return null;
}
import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;
-import java.util.Map;
import java.util.Vector;
import org.eclipse.core.resources.IFile;
@Test
public void testGetAnalysisModules() {
/* There should not be any modules at this point */
- Map<String, IAnalysisModule> modules = fExperiment.getAnalysisModules();
- assertTrue(modules.isEmpty());
+ Iterable<IAnalysisModule> modules = fExperiment.getAnalysisModules();
+ assertFalse(modules.iterator().hasNext());
}
// ------------------------------------------------------------------------
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;
-import java.util.Map;
-import java.util.Map.Entry;
import java.util.Vector;
import org.eclipse.core.runtime.FileLocator;
@Test
public void testGetModulesByClass() {
/* There should not be any modules at this point */
- Map<String, IAnalysisModule> modules = fTrace.getAnalysisModules();
- assertTrue(modules.isEmpty());
+ Iterable<IAnalysisModule> modules = fTrace.getAnalysisModules();
+ assertFalse(modules.iterator().hasNext());
/* Open the trace, the modules should be populated */
fTrace.traceOpened(new TmfTraceOpenedSignal(this, fTrace, null));
modules = fTrace.getAnalysisModules();
- Map<String, TestAnalysis> testModules = fTrace.getAnalysisModules(TestAnalysis.class);
- assertFalse(modules.isEmpty());
- assertFalse(testModules.isEmpty());
+ 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 */
- for (Entry<String, IAnalysisModule> module : modules.entrySet()) {
- if (module.getValue() instanceof TestAnalysis) {
- assertTrue(testModules.containsKey(module.getKey()));
+ for (IAnalysisModule module : modules) {
+ if (module instanceof TestAnalysis) {
+ IAnalysisModule otherModule = fTrace.getAnalysisModule(module.getId());
+ assertNotNull(otherModule);
+ assertTrue(otherModule.equals(module));
}
}
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.linuxtools.tmf.core.analysis.IAnalysisModule;
/**
* Interface for analysis modules providing state systems.
* @since 3.0
*/
@NonNullByDefault
-public interface ITmfAnalysisModuleWithStateSystems {
+public interface ITmfAnalysisModuleWithStateSystems extends IAnalysisModule {
/**
* Return a specific state system provided by this analysis.
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IStatus;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.linuxtools.tmf.core.analysis.IAnalysisModule;
import org.eclipse.linuxtools.tmf.core.component.ITmfEventProvider;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
* @since 2.0
* @deprecated State systems now should be provided by analysis and use
* {@link ITmfAnalysisModuleWithStateSystems} and retrieve the modules
- * with {@link TmfTrace#getAnalysisModules(Class)} with Class
+ * with {@link TmfTrace#getAnalysisModules} with Class
* being TmfStateSystemAnalysisModule.class
*/
@Deprecated
*/
void indexTrace(boolean waitForCompletion);
+ // ------------------------------------------------------------------------
+ // Analysis getters
+ // ------------------------------------------------------------------------
+
/**
- * Returns an analysis module with the given id
+ * Returns an analysis module with the given ID.
*
- * @param analysisId
- * The analysis module id
- * @return The {@link IAnalysisModule} object
+ * @param id
+ * The analysis module ID
+ * @return The {@link IAnalysisModule} object, or null if an analysis with
+ * the given ID does no exist.
* @since 3.0
*/
- IAnalysisModule getAnalysisModule(String analysisId);
+ @Nullable
+ IAnalysisModule getAnalysisModule(String id);
/**
- * Return a map of analysis modules that are of a given class. Module are
- * already casted to the requested class
+ * Get a list of all analysis modules currently available for this trace.
*
- * @param moduleclass
- * Class returned module must extend
- * @return List of modules of class moduleclass
+ * @return An iterable view of the analysis modules
* @since 3.0
*/
- <T> Map<String, T> getAnalysisModules(Class<T> moduleclass);
+ @NonNull
+ Iterable<IAnalysisModule> getAnalysisModules();
/**
- * Returns a map of analysis modules applicable to this trace. The key is
- * the analysis id.
+ * Get an analysis module belonging to this trace, with the specified ID and
+ * class.
*
- * This view should be read-only (implementations should use
- * {@link Collections#unmodifiableMap}).
+ * @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.
*
- * @return The map of analysis modules
+ * @param moduleClass
+ * Returned modules must extend this class
+ * @return List of modules of class moduleClass
* @since 3.0
*/
- Map<String, IAnalysisModule> getAnalysisModules();
+ @NonNull
+ <T> Iterable<T> getAnalysisModulesOfClass(Class<T> moduleClass);
// ------------------------------------------------------------------------
// Trace characteristics getters
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Collections;
-import java.util.HashMap;
+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.IFolder;
import org.eclipse.core.resources.IProject;
private ITmfTimestampTransform fTsTransform;
- private final Map<String, IAnalysisModule> fAnalysisModules = new LinkedHashMap<>();
+ private final Map<String, IAnalysisModule> fAnalysisModules =
+ Collections.synchronizedMap(new LinkedHashMap<String, IAnalysisModule>());
private static final String SYNCHRONIZATION_FORMULA_FILE = "sync_formula"; //$NON-NLS-1$
* @since 3.0
*/
@Override
- public final IAnalysisModule getAnalysisModule(String analysisId) {
+ public IAnalysisModule getAnalysisModule(String analysisId) {
return fAnalysisModules.get(analysisId);
}
+
+ /**
+ * @since 3.0
+ */
+ @Override
+ public Iterable<IAnalysisModule> getAnalysisModules() {
+ synchronized (fAnalysisModules) {
+ Set<IAnalysisModule> modules = new HashSet<>(fAnalysisModules.values());
+ return modules;
+ }
+ }
+
/**
* @since 3.0
*/
@Override
- public <T> Map<String, T> getAnalysisModules(Class<T> moduleclass) {
- Map<String, T> modules = new HashMap<>();
- for (Entry<String, IAnalysisModule> entry : fAnalysisModules.entrySet()) {
- if (moduleclass.isAssignableFrom(entry.getValue().getClass())) {
- modules.put(entry.getKey(), moduleclass.cast(entry.getValue()));
+ 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 modules;
+ return null;
}
/**
* @since 3.0
*/
@Override
- public Map<String, IAnalysisModule> getAnalysisModules() {
- return Collections.unmodifiableMap(fAnalysisModules);
+ 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;
}
/**
}
/* Clean up the analysis modules */
- for (IAnalysisModule module : fAnalysisModules.values()) {
- module.dispose();
+ synchronized (fAnalysisModules) {
+ for (IAnalysisModule module : fAnalysisModules.values()) {
+ module.dispose();
+ }
}
super.dispose();
ITmfTrace trace = traceElement.getTrace();
if (trace != null) {
IAnalysisModule module = trace.getAnalysisModule(fAnalysisId);
- return module.getHelpText();
+ if (module != null) {
+ return module.getHelpText();
+ }
}
}
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
-import java.util.Map.Entry;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.linuxtools.internal.tmf.ui.Activator;
-import org.eclipse.linuxtools.tmf.core.analysis.IAnalysisModule;
import org.eclipse.linuxtools.tmf.core.exceptions.AttributeNotFoundException;
import org.eclipse.linuxtools.tmf.core.exceptions.StateSystemDisposedException;
import org.eclipse.linuxtools.tmf.core.exceptions.StateValueTypeException;
import org.eclipse.linuxtools.tmf.core.signal.TmfTraceClosedSignal;
import org.eclipse.linuxtools.tmf.core.signal.TmfTraceOpenedSignal;
import org.eclipse.linuxtools.tmf.core.signal.TmfTraceSelectedSignal;
-import org.eclipse.linuxtools.tmf.core.statesystem.ITmfStateSystem;
import org.eclipse.linuxtools.tmf.core.statesystem.ITmfAnalysisModuleWithStateSystems;
+import org.eclipse.linuxtools.tmf.core.statesystem.ITmfStateSystem;
import org.eclipse.linuxtools.tmf.core.statevalue.ITmfStateValue;
import org.eclipse.linuxtools.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestamp;
* We will first do all the queries for this trace, then update that
* sub-tree in the UI thread.
*/
- Map<String, ITmfAnalysisModuleWithStateSystems> modules = currentTrace.getAnalysisModules(ITmfAnalysisModuleWithStateSystems.class);
+ Iterable<ITmfAnalysisModuleWithStateSystems> modules = currentTrace.getAnalysisModulesOfClass(ITmfAnalysisModuleWithStateSystems.class);
final Map<String, ITmfStateSystem> sss = new HashMap<>();
final Map<String, List<ITmfStateInterval>> fullStates =
new LinkedHashMap<>();
- for (Entry<String, ITmfAnalysisModuleWithStateSystems> entry : modules.entrySet()) {
+ for (ITmfAnalysisModuleWithStateSystems module : modules) {
/*
* FIXME: For now, this view is a way to execute and display
* state system. But with phase 2 of analysis API, we won't want
* to run state system that have not been requested. We will
* leave the title, but there won't be anything underneath.
*/
- ITmfAnalysisModuleWithStateSystems module = entry.getValue();
- if (module instanceof IAnalysisModule) {
- IAnalysisModule mod = (IAnalysisModule) module;
- mod.schedule();
- mod.waitForCompletion(new NullProgressMonitor());
- }
+ module.schedule();
+ module.waitForCompletion(new NullProgressMonitor());
for (ITmfStateSystem ss : module.getStateSystems()) {
if (ss == null) {
continue;
/* For each trace... */
for (int traceNb = 0; traceNb < traces.length; traceNb++) {
- Map<String, ITmfAnalysisModuleWithStateSystems> modules = traces[traceNb].getAnalysisModules(ITmfAnalysisModuleWithStateSystems.class);
+ Iterable<ITmfAnalysisModuleWithStateSystems> modules = traces[traceNb].getAnalysisModulesOfClass(ITmfAnalysisModuleWithStateSystems.class);
/* For each state system associated with this trace... */
int ssNb = 0;
- for (Entry<String, ITmfAnalysisModuleWithStateSystems> module : modules.entrySet()) {
+ for (ITmfAnalysisModuleWithStateSystems module : modules) {
/*
* Even though we only use the value, it just feels safer to
* iterate the same way as before to keep the order the same.
*/
- for (final ITmfStateSystem ss : module.getValue().getStateSystems()) {
+ for (final ITmfStateSystem ss : module.getStateSystems()) {
final int traceNb1 = traceNb;
final int ssNb1 = ssNb;
if (ss != null) {
projects / deliverable / tracecompass.git / commitdiff
