import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.tracecompass.analysis.os.linux.core.latency.SystemCallLatencyAnalysis;
-import org.eclipse.tracecompass.analysis.timing.core.segmentstore.AbstractSegmentStoreAnalysisModule;
+import org.eclipse.tracecompass.analysis.timing.core.segmentstore.ISegmentStoreProvider;
import org.eclipse.tracecompass.analysis.timing.ui.views.segmentstore.density.AbstractSegmentStoreDensityViewer;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
}
@Override
- protected @Nullable AbstractSegmentStoreAnalysisModule getSegmentStoreAnalysisModule(ITmfTrace trace) {
+ protected @Nullable ISegmentStoreProvider getSegmentStoreProvider(ITmfTrace trace) {
return TmfTraceUtils.getAnalysisModuleOfClass(trace, SystemCallLatencyAnalysis.class, SystemCallLatencyAnalysis.ID);
}
}
protected AbstractSegmentStoreTableViewer createSegmentStoreTableViewer(Composite parent) {
return new SystemCallLatencyTableViewer(new TableViewer(parent, SWT.FULL_SELECTION | SWT.VIRTUAL)) {
@Override
- protected void createAnalysisColumns() {
- super.createAnalysisColumns();
+ protected void createProviderColumns() {
+ super.createProviderColumns();
Table t = (Table) getControl();
t.setColumnOrder(new int[] { 2, 3, 0, 1 });
}
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.tracecompass.analysis.os.linux.core.latency.SystemCallLatencyAnalysis;
-import org.eclipse.tracecompass.analysis.timing.core.segmentstore.AbstractSegmentStoreAnalysisModule;
+import org.eclipse.tracecompass.analysis.timing.core.segmentstore.ISegmentStoreProvider;
import org.eclipse.tracecompass.analysis.timing.ui.views.segmentstore.scatter.AbstractSegmentStoreScatterGraphViewer;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
}
@Override
- protected @Nullable AbstractSegmentStoreAnalysisModule getSegmentStoreAnalysisModule(ITmfTrace trace) {
+ protected @Nullable ISegmentStoreProvider getSegmentStoreProvider(ITmfTrace trace) {
return TmfTraceUtils.getAnalysisModuleOfClass(trace, SystemCallLatencyAnalysis.class, SystemCallLatencyAnalysis.ID);
}
}
\ No newline at end of file
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.tracecompass.analysis.os.linux.core.latency.SystemCallLatencyAnalysis;
-import org.eclipse.tracecompass.analysis.timing.core.segmentstore.AbstractSegmentStoreAnalysisModule;
+import org.eclipse.tracecompass.analysis.timing.core.segmentstore.ISegmentStoreProvider;
import org.eclipse.tracecompass.analysis.timing.ui.views.segmentstore.table.AbstractSegmentStoreTableViewer;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
// ------------------------------------------------------------------------
@Override
- protected @Nullable AbstractSegmentStoreAnalysisModule getSegmentStoreAnalysisModule(ITmfTrace trace) {
+ protected @Nullable ISegmentStoreProvider getSegmentStoreProvider(ITmfTrace trace) {
return TmfTraceUtils.getAnalysisModuleOfClass(trace, SystemCallLatencyAnalysis.class, SystemCallLatencyAnalysis.ID);
}
}
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
-import java.util.Collection;
+import java.util.Collections;
import java.util.List;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
-import com.google.common.collect.ImmutableList;
-
/**
* Abstract analysis module to generate a segment store. It is a base class that
* can be used as a shortcut by analysis who just need to build a single segment
* @since 2.0
*
*/
-public abstract class AbstractSegmentStoreAnalysisModule extends TmfAbstractAnalysisModule {
+public abstract class AbstractSegmentStoreAnalysisModule extends TmfAbstractAnalysisModule implements ISegmentStoreProvider {
private final ListenerList fListeners = new ListenerList(ListenerList.IDENTITY);
private @Nullable ITmfEventRequest fOngoingRequest = null;
- /**
- * Listener for the viewers
- *
- * @param listener
- * listener for each type of viewer
- */
+ @Override
public void addListener(IAnalysisProgressListener listener) {
fListeners.add(listener);
}
- /**
- * Removes a listener for the viewers
- *
- * @param listener
- * listener for each type of viewer to remove
- */
+ @Override
public void removeListener(IAnalysisProgressListener listener) {
fListeners.remove(listener);
}
return listeners;
}
- /**
- * Return the pre-defined set of segment aspects exposed by this analysis.
- *
- * It should not be null, but could be empty.
- *
- * @return The segment aspects for this analysis
- */
+ @Override
public Iterable<ISegmentAspect> getSegmentAspects() {
- Collection<ISegmentAspect> coll = ImmutableList.of();
- return checkNotNull(coll);
+ return Collections.emptyList();
}
/**
*/
protected abstract Object[] readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException;
- /**
- * Returns the segment store built by this analysis
- *
- * @return The segment store
- */
+ @Override
public @Nullable ISegmentStore<ISegment> getSegmentStore() {
return fSegmentStore;
}
public interface IAnalysisProgressListener {
/**
- * Called at the end of the analysis
+ * Called at the end of the segment store construction
*
- * @param activeAnalysis
+ * @param segmentProvider
* analysis that is running
*
* @param data
* segment store of the latency analysis
*/
- void onComplete(AbstractSegmentStoreAnalysisModule activeAnalysis, ISegmentStore<ISegment> data);
+ void onComplete(ISegmentStoreProvider segmentProvider, ISegmentStore<ISegment> data);
}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2016 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
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.analysis.timing.core.segmentstore;
+
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.tracecompass.segmentstore.core.ISegment;
+import org.eclipse.tracecompass.segmentstore.core.ISegmentStore;
+import org.eclipse.tracecompass.tmf.core.segment.ISegmentAspect;
+
+/**
+ * Segment store provider. Useful to populate views.
+ *
+ * @author Matthew Khouzam
+ * @since 2.0
+ */
+public interface ISegmentStoreProvider {
+
+ /**
+ * Add a listener for the viewers
+ *
+ * @param listener
+ * listener for each type of viewer
+ */
+ void addListener(IAnalysisProgressListener listener);
+
+ /**
+ * Remove listener for the viewers
+ *
+ * @param listener
+ * listener for each type of viewer
+ */
+ void removeListener(IAnalysisProgressListener listener);
+
+ /**
+ * Return the pre-defined set of segment aspects exposed by this analysis.
+ *
+ * It should not be null, but could be empty.
+ *
+ * @return The segment aspects for this analysis
+ */
+ Iterable<ISegmentAspect> getSegmentAspects();
+
+ /**
+ * Returns the result in a from the analysis in a ISegmentStore
+ *
+ * @return Results from the analysis in a ISegmentStore
+ */
+ @Nullable ISegmentStore<ISegment> getSegmentStore();
+
+}
\ No newline at end of file
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
-import org.eclipse.tracecompass.analysis.timing.core.segmentstore.AbstractSegmentStoreAnalysisModule;
import org.eclipse.tracecompass.analysis.timing.core.segmentstore.IAnalysisProgressListener;
+import org.eclipse.tracecompass.analysis.timing.core.segmentstore.ISegmentStoreProvider;
import org.eclipse.tracecompass.analysis.timing.ui.views.segmentstore.SubSecondTimeWithUnitFormat;
import org.eclipse.tracecompass.common.core.NonNullUtils;
import org.eclipse.tracecompass.internal.analysis.timing.ui.views.segmentstore.density.MouseDragZoomProvider;
import org.eclipse.tracecompass.segmentstore.core.ISegment;
import org.eclipse.tracecompass.segmentstore.core.ISegmentStore;
import org.eclipse.tracecompass.segmentstore.core.SegmentComparators;
+import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
import com.google.common.collect.Lists;
/**
- * Displays the segment store analysis data in a density chart.
+ * Displays the segment store provider data in a density chart.
*
* @author Matthew Khouzam
* @author Marc-Andre Laperle
private @Nullable ITmfTrace fTrace;
private @Nullable IAnalysisProgressListener fListener;
- private @Nullable AbstractSegmentStoreAnalysisModule fAnalysisModule;
+ private @Nullable ISegmentStoreProvider fSegmentStoreProvider;
private TmfTimeRange fCurrentTimeRange = TmfTimeRange.NULL_RANGE;
private List<ISegmentStoreDensityViewerDataListener> fListeners;
}
/**
- * Returns the segment store analysis module
+ * Returns the segment store provider
*
* @param trace
* The trace to consider
- * @return the analysis module
+ * @return the
*/
- protected @Nullable abstract AbstractSegmentStoreAnalysisModule getSegmentStoreAnalysisModule(ITmfTrace trace);
+ protected @Nullable abstract ISegmentStoreProvider getSegmentStoreProvider(ITmfTrace trace);
@Nullable
private static ITmfTrace getTrace() {
}
private @Nullable List<ISegment> computeData(final TmfTimeRange timeRange, final Range durationRange) {
- final AbstractSegmentStoreAnalysisModule analysisModule = fAnalysisModule;
- if (analysisModule == null) {
+ final ISegmentStoreProvider segmentProvider = fSegmentStoreProvider;
+ if (segmentProvider == null) {
return null;
}
- final ISegmentStore<ISegment> segStore = analysisModule.getSegmentStore();
+ final ISegmentStore<ISegment> segStore = segmentProvider.getSegmentStore();
if (segStore == null) {
return null;
}
if (trace == null) {
return;
}
- fAnalysisModule = getSegmentStoreAnalysisModule(trace);
+ fSegmentStoreProvider = getSegmentStoreProvider(trace);
fCurrentTimeRange = NonNullUtils.checkNotNull(signal.getCurrentRange());
updateWithRange(fCurrentTimeRange);
}
@Override
public void dispose() {
- if (fAnalysisModule != null && fListener != null) {
- fAnalysisModule.removeListener(fListener);
+ if (fSegmentStoreProvider != null && fListener != null) {
+ fSegmentStoreProvider.removeListener(fListener);
}
fDragZoomProvider.deregister();
fTooltipProvider.deregister();
fCurrentTimeRange = windowRange;
if (trace != null) {
- fAnalysisModule = getSegmentStoreAnalysisModule(trace);
- final AbstractSegmentStoreAnalysisModule module = fAnalysisModule;
- if (module != null) {
- fListener = (activeAnalysis, data) -> updateWithRange(windowRange);
- module.addListener(fListener);
- module.schedule();
+ fSegmentStoreProvider = getSegmentStoreProvider(trace);
+ final ISegmentStoreProvider provider = fSegmentStoreProvider;
+ if (provider != null) {
+ fListener = (segmentProvider, data) -> updateWithRange(windowRange);
+ provider.addListener(fListener);
+ if( provider instanceof IAnalysisModule) {
+ ((IAnalysisModule) provider).schedule();
+ }
}
}
zoom(new Range(0, Long.MAX_VALUE));
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
-import org.eclipse.tracecompass.analysis.timing.core.segmentstore.AbstractSegmentStoreAnalysisModule;
import org.eclipse.tracecompass.analysis.timing.core.segmentstore.IAnalysisProgressListener;
+import org.eclipse.tracecompass.analysis.timing.core.segmentstore.ISegmentStoreProvider;
import org.eclipse.tracecompass.analysis.timing.ui.views.segmentstore.SubSecondTimeWithUnitFormat;
import org.eclipse.tracecompass.common.core.NonNullUtils;
import org.eclipse.tracecompass.internal.analysis.timing.ui.Activator;
import org.eclipse.tracecompass.segmentstore.core.ISegment;
import org.eclipse.tracecompass.segmentstore.core.ISegmentStore;
import org.eclipse.tracecompass.segmentstore.core.SegmentComparators;
+import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalManager;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
import org.swtchart.Range;
/**
- * Displays the segment store analysis data in a scatter graph
+ * Displays the segment store provider data in a scatter graph
*
* @author France Lapointe Nguyen
* @author Matthew Khouzam - reduced memory usage
return new Status(IStatus.ERROR, Activator.PLUGIN_ID, "Monitor is null"); //$NON-NLS-1$
}
- AbstractSegmentStoreAnalysisModule module = getAnalysisModule();
+ ISegmentStoreProvider segmentProvider = getSegmentProvider();
final long startTimeInNanos = fCurrentRange.getStartTime().toNanos();
final long endTimeInNanos = fCurrentRange.getEndTime().toNanos();
- if (module == null) {
+ if (segmentProvider == null) {
setWindowRange(startTimeInNanos, endTimeInNanos);
redraw(statusMonitor, startTimeInNanos, startTimeInNanos, Collections.EMPTY_LIST);
- return new Status(IStatus.WARNING, Activator.PLUGIN_ID, "Analysis module not available"); //$NON-NLS-1$
+ return new Status(IStatus.WARNING, Activator.PLUGIN_ID, "segment provider not available"); //$NON-NLS-1$
}
- final ISegmentStore<ISegment> segStore = module.getSegmentStore();
+ final ISegmentStore<ISegment> segStore = segmentProvider.getSegmentStore();
if (segStore == null) {
setWindowRange(startTimeInNanos, endTimeInNanos);
redraw(statusMonitor, startTimeInNanos, startTimeInNanos, Collections.EMPTY_LIST);
- return new Status(IStatus.INFO, Activator.PLUGIN_ID, "Analysis module does not have results"); //$NON-NLS-1$
+ return new Status(IStatus.INFO, Activator.PLUGIN_ID, "Segment provider does not have segments"); //$NON-NLS-1$
}
final long startTime = fCurrentRange.getStartTime().getValue();
// ------------------------------------------------------------------------
/**
- * Listener to update the model with the semgent store analysis results
- * once the analysis is fully completed
+ * Listener to update the model with the segment store provider results once
+ * its segment store is fully completed
*/
- private final class AnalysisProgressListener implements IAnalysisProgressListener {
+ private final class SegmentStoreProviderProgressListener implements IAnalysisProgressListener {
@Override
- public void onComplete(AbstractSegmentStoreAnalysisModule activeAnalysis, ISegmentStore<ISegment> results) {
+ public void onComplete(ISegmentStoreProvider segmentProvider, ISegmentStore<ISegment> segmentStore) {
// Only update the model if trace that was analyzed is active trace
- if (activeAnalysis.equals(getAnalysisModule())) {
- updateModel(results);
+ if (segmentProvider.equals(getSegmentProvider())) {
+ updateModel(segmentStore);
updateRange(TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange());
}
}
private Collection<ISegment> fDisplayData = Collections.EMPTY_LIST;
/**
- * Analysis completion listener
+ * Provider completion listener
*/
- private AnalysisProgressListener fListener;
+ private SegmentStoreProviderProgressListener fListener;
/**
- * Current analysis module
+ * Current segment provider
*/
- private @Nullable AbstractSegmentStoreAnalysisModule fAnalysisModule;
+ private @Nullable ISegmentStoreProvider fSegmentProvider;
private @Nullable Job fCompactingJob;
public AbstractSegmentStoreScatterGraphViewer(Composite parent, String title, String xLabel, String yLabel) {
super(parent, title, xLabel, yLabel);
setTooltipProvider(new SegmentStoreScatterGraphTooltipProvider(this));
- fListener = new AnalysisProgressListener();
+ fListener = new SegmentStoreProviderProgressListener();
ITmfTrace trace = TmfTraceManager.getInstance().getActiveTrace();
- initializeModule(trace);
+ initializeProvider(trace);
getSwtChart().getLegend().setVisible(false);
getSwtChart().getAxisSet().getYAxis(0).getTick().setFormat(FORMAT);
}
- private final void initializeModule(@Nullable ITmfTrace trace) {
+ private final void initializeProvider(@Nullable ITmfTrace trace) {
if (trace != null) {
- final AbstractSegmentStoreAnalysisModule analysisModuleOfClass = getSegmentStoreAnalysisModule(trace);
- if (analysisModuleOfClass != null) {
- analysisModuleOfClass.addListener(fListener);
- setData(analysisModuleOfClass);
+ final ISegmentStoreProvider segmentStoreProvider = getSegmentStoreProvider(trace);
+ if (segmentStoreProvider != null) {
+ segmentStoreProvider.addListener(fListener);
+ setData(segmentStoreProvider);
updateRange(TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange());
}
}
@Override
protected void initializeDataSource() {
ITmfTrace trace = getTrace();
- initializeModule(trace);
+ initializeProvider(trace);
if (trace != null) {
- setData(getSegmentStoreAnalysisModule(trace));
+ setData(getSegmentStoreProvider(trace));
}
}
}
/**
- * Set the data into the viewer. Will update model is analysis is completed
- * or run analysis if not completed
+ * Set the data into the viewer. If the provider is an analysis, it will
+ * update the model if the analysis is completed or run the analysis if not
+ * completed
*
- * @param analysis
- * Segment store analysis module
+ * @param provider
+ * Segment store provider
*/
- public void setData(@Nullable AbstractSegmentStoreAnalysisModule analysis) {
- if (analysis == null) {
+ public void setData(@Nullable ISegmentStoreProvider provider) {
+ if (provider == null) {
updateModel(null);
return;
}
- ISegmentStore<ISegment> segStore = analysis.getSegmentStore();
- // If results are not null, then analysis is completed and model can be
- // updated
+ ISegmentStore<ISegment> segStore = provider.getSegmentStore();
+ // If results are not null, then segment store is completed and model
+ // can be updated
if (segStore != null) {
updateModel(segStore);
- setAnalysisModule(analysis);
+ setSegmentProvider(provider);
return;
}
updateModel(null);
- analysis.addListener(fListener);
- analysis.schedule();
- setAnalysisModule(analysis);
+ provider.addListener(fListener);
+ if (provider instanceof IAnalysisModule) {
+ ((IAnalysisModule) provider).schedule();
+ }
+ setSegmentProvider(provider);
}
/**
- * Returns the segment store analysis module
+ * Returns the segment store provider
*
* @param trace
* The trace to consider
- * @return the analysis module
+ * @return the segment store provider
*/
- protected @Nullable abstract AbstractSegmentStoreAnalysisModule getSegmentStoreAnalysisModule(ITmfTrace trace);
+ protected @Nullable abstract ISegmentStoreProvider getSegmentStoreProvider(ITmfTrace trace);
// ------------------------------------------------------------------------
// Signal handlers
setWindowRange(
timeRange.getStartTime().toNanos(),
timeRange.getEndTime().toNanos());
- setData(getSegmentStoreAnalysisModule(trace));
+ setData(getSegmentStoreProvider(trace));
updateRange(timeRange);
}
}
setTrace(trace);
if (trace != null) {
- final AbstractSegmentStoreAnalysisModule analysisModuleOfClass = getSegmentStoreAnalysisModule(trace);
+ final ISegmentStoreProvider segmentStoreProvider = getSegmentStoreProvider(trace);
final TmfTimeRange timeRange = TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange();
setWindowRange(
timeRange.getStartTime().toNanos(),
timeRange.getEndTime().toNanos());
- setData(analysisModuleOfClass);
+ setData(segmentStoreProvider);
}
}
if (signal != null) {
// Check if there is no more opened trace
if (TmfTraceManager.getInstance().getActiveTrace() == null) {
- AbstractSegmentStoreAnalysisModule analysis = getAnalysisModule();
- if (analysis != null) {
- analysis.removeListener(fListener);
+ ISegmentStoreProvider provider = getSegmentProvider();
+ if (provider != null) {
+ provider.removeListener(fListener);
}
clearContent();
}
}
}
- private @Nullable AbstractSegmentStoreAnalysisModule getAnalysisModule() {
- return fAnalysisModule;
+ private @Nullable ISegmentStoreProvider getSegmentProvider() {
+ return fSegmentProvider;
}
- private void setAnalysisModule(AbstractSegmentStoreAnalysisModule analysisModule) {
- fAnalysisModule = analysisModule;
+ private void setSegmentProvider(ISegmentStoreProvider provider) {
+ fSegmentProvider = provider;
}
}
\ No newline at end of file
*/
private void setInitialData() {
if (fSegmentStoreViewer != null) {
- fSegmentStoreViewer.setData(fSegmentStoreViewer.getAnalysisModule());
+ fSegmentStoreViewer.setData(fSegmentStoreViewer.getSegmentProvider());
}
}
}
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.TableColumn;
-import org.eclipse.tracecompass.analysis.timing.core.segmentstore.AbstractSegmentStoreAnalysisModule;
import org.eclipse.tracecompass.analysis.timing.core.segmentstore.IAnalysisProgressListener;
+import org.eclipse.tracecompass.analysis.timing.core.segmentstore.ISegmentStoreProvider;
import org.eclipse.tracecompass.common.core.NonNullUtils;
import org.eclipse.tracecompass.internal.analysis.timing.ui.views.segmentstore.table.Messages;
import org.eclipse.tracecompass.internal.analysis.timing.ui.views.segmentstore.table.SegmentStoreContentProvider;
import org.eclipse.tracecompass.segmentstore.core.ISegment;
import org.eclipse.tracecompass.segmentstore.core.ISegmentStore;
import org.eclipse.tracecompass.segmentstore.core.SegmentComparators;
+import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
import org.eclipse.tracecompass.tmf.core.segment.ISegmentAspect;
import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
import org.eclipse.tracecompass.tmf.ui.viewers.table.TmfSimpleTableViewer;
/**
- * Displays the segment store analysis data in a column table
+ * Displays the segment store provider data in a column table
*
* @author France Lapointe Nguyen
* @since 2.0
/**
* Abstract class for the column label provider for the segment store
- * analysis table viewer
+ * provider table viewer
*/
private abstract class SegmentStoreTableColumnLabelProvider extends ColumnLabelProvider {
}
/**
- * Listener to update the model with the segment store analysis results
- * once the analysis is fully completed
+ * Listener to update the model with the segment store provider results once
+ * its store is fully completed
*/
- private final class AnalysisProgressListener implements IAnalysisProgressListener {
+ private final class SegmentStoreProviderProgressListener implements IAnalysisProgressListener {
@Override
- public void onComplete(AbstractSegmentStoreAnalysisModule activeAnalysis, ISegmentStore<ISegment> data) {
- // Check if the active trace was changed while the analysis was
- // running
- if (activeAnalysis.equals(fAnalysisModule)) {
+ public void onComplete(ISegmentStoreProvider activeProvider, ISegmentStore<ISegment> data) {
+ // Check if the active trace was changed while the provider was
+ // building its segment store
+ if (activeProvider.equals(fSegmentProvider)) {
updateModel(data);
}
}
}
/**
- * Current segment store analysis module
+ * Current segment store provider
*/
- private @Nullable AbstractSegmentStoreAnalysisModule fAnalysisModule = null;
+ private @Nullable ISegmentStoreProvider fSegmentProvider = null;
/**
- * Analysis progress listener
+ * provider progress listener
*/
- private AnalysisProgressListener fListener;
+ private SegmentStoreProviderProgressListener fListener;
/**
* Flag to create columns once
getTableViewer().setContentProvider(new SegmentStoreContentProvider());
ITmfTrace trace = TmfTraceManager.getInstance().getActiveTrace();
if (trace != null) {
- fAnalysisModule = getSegmentStoreAnalysisModule(trace);
+ fSegmentProvider = getSegmentStoreProvider(trace);
}
createColumns();
getTableViewer().getTable().addSelectionListener(new TableSelectionListener());
addPackListener();
- fListener = new AnalysisProgressListener();
+ fListener = new SegmentStoreProviderProgressListener();
}
// ------------------------------------------------------------------------
}
/**
- * Create columns specific to the analysis
+ * Create columns specific to the provider
*/
- protected void createAnalysisColumns() {
+ protected void createProviderColumns() {
if (!fColumnsCreated) {
- AbstractSegmentStoreAnalysisModule analysis = getAnalysisModule();
- if (analysis != null) {
- for (final ISegmentAspect aspect : analysis.getSegmentAspects()) {
+ ISegmentStoreProvider provider = getSegmentProvider();
+ if (provider != null) {
+ for (final ISegmentAspect aspect : provider.getSegmentAspects()) {
createColumn(aspect.getName(), new SegmentStoreTableColumnLabelProvider() {
@Override
public String getTextForSegment(ISegment input) {
return NonNullUtils.nullToEmptyString(aspect.resolve(input));
}
},
- aspect.getComparator());
+ aspect.getComparator());
}
}
fColumnsCreated = true;
}
/**
- * Set the data into the viewer. Will update model is analysis is completed
- * or run analysis if not completed
+ * Set the data into the viewer. It will update the model. If the provider
+ * is an analysis, the analysis will be scheduled.
*
- * @param analysis
- * segment store analysis module
+ * @param provider
+ * segment store provider
*/
- public void setData(@Nullable AbstractSegmentStoreAnalysisModule analysis) {
- // Set the current segment store analysis module
- fAnalysisModule = analysis;
- if (analysis == null) {
+ public void setData(@Nullable ISegmentStoreProvider provider) {
+ // Set the current segment store provider
+ fSegmentProvider = provider;
+ if (provider == null) {
updateModel(null);
return;
}
- createAnalysisColumns();
+ createProviderColumns();
- ISegmentStore<ISegment> segStore = analysis.getSegmentStore();
- // If results are not null, then analysis is completed and model can be
- // updated
+ ISegmentStore<ISegment> segStore = provider.getSegmentStore();
+ // If results are not null, then the segment of the provider is ready
+ // and model can be updated
if (segStore != null) {
updateModel(segStore);
return;
}
- // If results are null, then add completion listener and run analysis
+ // If results are null, then add completion listener and if the provider
+ // is an analysis, run the analysis
updateModel(null);
- analysis.addListener(fListener);
- analysis.schedule();
+ provider.addListener(fListener);
+ if (provider instanceof IAnalysisModule) {
+ ((IAnalysisModule) provider).schedule();
+ }
}
/**
- * Returns the segment store analysis module
+ * Returns the segment store provider
+ *
* @param trace
* The trace to consider
- * @return the segment store analysis module
+ * @return the segment store provider
*/
- protected @Nullable abstract AbstractSegmentStoreAnalysisModule getSegmentStoreAnalysisModule(ITmfTrace trace);
+ protected @Nullable abstract ISegmentStoreProvider getSegmentStoreProvider(ITmfTrace trace);
@Override
protected void appendToTablePopupMenu(IMenuManager manager, IStructuredSelection sel) {
// ------------------------------------------------------------------------
/**
- * Get current segment store analysis module
+ * Get current segment store provider
*
- * @return current segment store analysis module
+ * @return current segment store provider
*/
- public @Nullable AbstractSegmentStoreAnalysisModule getAnalysisModule() {
- return fAnalysisModule;
+ public @Nullable ISegmentStoreProvider getSegmentProvider() {
+ return fSegmentProvider;
}
// ------------------------------------------------------------------------
public void traceSelected(TmfTraceSelectedSignal signal) {
ITmfTrace trace = signal.getTrace();
if (trace != null) {
- setData(getSegmentStoreAnalysisModule(trace));
+ setData(getSegmentStoreProvider(trace));
}
}
public void traceOpened(TmfTraceOpenedSignal signal) {
ITmfTrace trace = signal.getTrace();
if (trace != null) {
- setData(getSegmentStoreAnalysisModule(trace));
+ setData(getSegmentStoreProvider(trace));
}
}
refresh();
}
- AbstractSegmentStoreAnalysisModule analysis = getAnalysisModule();
- if ((analysis != null)) {
- analysis.removeListener(fListener);
+ ISegmentStoreProvider provider = getSegmentProvider();
+ if ((provider != null)) {
+ provider.removeListener(fListener);
}
}
}
}
}
-
@Override
public boolean containsAll(@Nullable Collection<?> c) {
fLock.readLock().lock();
@Override
public void clear() {
- throw new UnsupportedOperationException();
+ fLock.writeLock().lock();
+ try {
+ fSize = 0;
+ fEndTimesIndex.clear();
+ fStartTimesIndex.clear();
+ } finally {
+ fLock.writeLock().unlock();
+ }
}
// ------------------------------------------------------------------------
projects / deliverable / tracecompass.git / commitdiff
