\r
package org.eclipse.linuxtools.tmf.ui.parsers.custom;\r
\r
+import java.io.IOException;\r
import java.util.regex.Matcher;\r
\r
import org.eclipse.linuxtools.tmf.io.BufferedRandomAccessFile;\r
public CustomTxtTraceContext(ITmfLocation<?> location, long rank) {\r
super(location, rank);\r
}\r
+\r
+ @Override\r
+ public void dispose() {\r
+ if (raFile != null) {\r
+ try {\r
+ raFile.close();\r
+ } catch (IOException e) {\r
+ }\r
+ }\r
+ super.dispose();\r
+ }\r
+\r
}
\ No newline at end of file
\r
package org.eclipse.linuxtools.tmf.ui.parsers.custom;\r
\r
+import java.io.IOException;\r
+\r
import org.eclipse.linuxtools.tmf.io.BufferedRandomAccessFile;\r
import org.eclipse.linuxtools.tmf.trace.ITmfLocation;\r
import org.eclipse.linuxtools.tmf.trace.TmfContext;\r
public CustomXmlTraceContext(ITmfLocation<?> location, long rank) {\r
super(location, rank);\r
}\r
+\r
+ @Override\r
+ public void dispose() {\r
+ if (raFile != null) {\r
+ try {\r
+ raFile.close();\r
+ } catch (IOException e) {\r
+ }\r
+ }\r
+ super.dispose();\r
+ }\r
+\r
}
\ No newline at end of file
import org.eclipse.ui.IEditorPart;\r
import org.eclipse.ui.IEditorReference;\r
\r
-\r
-public class TimeChartView extends TmfView implements ITmfTimeScaleSelectionListener, ITmfTimeSelectionListener, IColorSettingsListener, IResourceChangeListener, ITmfEventsFilterListener {\r
+public class TimeChartView extends TmfView implements ITmfTimeScaleSelectionListener, ITmfTimeSelectionListener, IColorSettingsListener,\r
+ IResourceChangeListener, ITmfEventsFilterListener {\r
\r
public static final String ID = "org.eclipse.linuxtools.tmf.ui.views.timechart"; //$NON-NLS-1$\r
\r
private static final byte TIMESTAMP_SCALE = -9;\r
- \r
- private int fDisplayWidth;\r
+\r
+ private final int fDisplayWidth;\r
private Composite fComposite;\r
private ITimeAnalysisViewer fViewer;\r
- private ArrayList<TimeChartAnalysisEntry> fTimeAnalysisEntries = new ArrayList<TimeChartAnalysisEntry>();\r
- private Map<ITmfTrace, TimeChartDecorationProvider> fDecorationProviders = new HashMap<ITmfTrace, TimeChartDecorationProvider>();\r
+ private final ArrayList<TimeChartAnalysisEntry> fTimeAnalysisEntries = new ArrayList<TimeChartAnalysisEntry>();\r
+ private final Map<ITmfTrace, TimeChartDecorationProvider> fDecorationProviders = new HashMap<ITmfTrace, TimeChartDecorationProvider>();\r
private ArrayList<DecorateThread> fDecorateThreads;\r
private long fStartTime = 0;\r
private long fStopTime = Long.MAX_VALUE;\r
private boolean fRefreshBusy = false;\r
private boolean fRefreshPending = false;\r
- private Object fSyncObj = new Object();\r
+ private final Object fSyncObj = new Object();\r
\r
public TimeChartView() {\r
super("Time Chart"); //$NON-NLS-1$\r
gl.marginWidth = 0;\r
gl.marginHeight = 0;\r
fComposite.setLayout(gl);\r
- \r
+\r
fViewer = TmfViewerFactory.createViewer(fComposite, new TimeChartAnalysisProvider());\r
fViewer.groupTraces(false);\r
fViewer.setTimeCalendarFormat(true);\r
fViewer.addWidgetTimeScaleSelectionListner(this);\r
fViewer.addWidgetSelectionListner(this);\r
fViewer.setMinimumItemWidth(1);\r
- \r
+\r
IEditorReference[] editorReferences = getSite().getPage().getEditorReferences();\r
for (IEditorReference editorReference : editorReferences) {\r
IEditorPart editor = editorReference.getEditor(false);\r
}\r
}\r
fViewer.display(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));\r
- \r
+\r
fDecorateThreads = new ArrayList<DecorateThread>();\r
ColorSettingsManager.addColorSettingsListener(this);\r
ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.POST_CHANGE);\r
\r
@Override\r
public void dispose() {\r
- ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);\r
- for (DecorateThread thread : fDecorateThreads) {\r
- thread.cancel();\r
- }\r
+ ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);\r
+ for (DecorateThread thread : fDecorateThreads) {\r
+ thread.cancel();\r
+ }\r
ColorSettingsManager.removeColorSettingsListener(this);\r
- super.dispose();\r
+ super.dispose();\r
}\r
\r
- @Override\r
+ @Override\r
public void setFocus() {\r
super.setFocus();\r
fViewer.setFocus();\r
}\r
- \r
+\r
private class ProcessTraceThread extends Thread {\r
\r
- private TimeChartAnalysisEntry fTimeAnalysisEntry;\r
+ private final TimeChartAnalysisEntry fTimeAnalysisEntry;\r
\r
public ProcessTraceThread(TimeChartAnalysisEntry timeAnalysisEntry) {\r
- super("ProcessTraceJob:"+timeAnalysisEntry.getName()); //$NON-NLS-1$\r
+ super("ProcessTraceJob:" + timeAnalysisEntry.getName()); //$NON-NLS-1$\r
fTimeAnalysisEntry = timeAnalysisEntry;\r
}\r
\r
updateTraceEntry(fTimeAnalysisEntry, Long.MAX_VALUE, 0, Long.MAX_VALUE);\r
}\r
}\r
- \r
+\r
private void updateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry, long stopRank, long startTime, long stopTime) {\r
ITmfTrace trace = timeAnalysisEntry.getTrace();\r
TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(trace);\r
if (decorationProvider == null) {\r
- return; // the trace has been closed\r
+ return; // the trace has been closed\r
}\r
TmfContext context = null;\r
- //TmfTimestamp lastTimestamp = null;\r
+ // TmfTimestamp lastTimestamp = null;\r
boolean done = false;\r
while (!done) {\r
synchronized (timeAnalysisEntry) {\r
break;\r
}\r
if (context == null || context.getRank() != timeAnalysisEntry.getLastRank()) {\r
+ if (context != null) {\r
+ context.dispose();\r
+ }\r
if (timeAnalysisEntry.getLastRank() != -1) {\r
context = trace.seekEvent(timeAnalysisEntry.getLastRank());\r
} else {\r
- //context = trace.seekLocation(null);\r
+ // context = trace.seekLocation(null);\r
context = trace.seekEvent(0);\r
}\r
}\r
done = true;\r
break;\r
}\r
- //if (!event.getTimestamp().equals(lastTimestamp)) {\r
+ // if (!event.getTimestamp().equals(lastTimestamp)) {\r
TimeChartEvent timeEvent = new TimeChartEvent(timeAnalysisEntry, event, rank, decorationProvider);\r
if (timeEvent.getTime() >= startTime && timeEvent.getTime() <= stopTime) {\r
timeAnalysisEntry.addTraceEvent(timeEvent);\r
}\r
- //lastTimestamp = event.getTimestamp();\r
- //} *** commented out so that color setting priority gets set even if the event has same time\r
+ // lastTimestamp = event.getTimestamp();\r
+ // } *** commented out so that color setting priority gets\r
+ // set even if the event has same time\r
if (context.getRank() == trace.getNbEvents() || context.getRank() == stopRank) {\r
done = true;\r
break;\r
}\r
if (context.getRank() % trace.getCacheSize() == 1) {\r
- // break for UI refresh\r
+ // break for UI refresh\r
break;\r
}\r
}\r
- //timeAnalysisEntry.setLastRank(Math.min(trace.getNbEvents(), stopRank));\r
+ // timeAnalysisEntry.setLastRank(Math.min(trace.getNbEvents(),\r
+ // stopRank));\r
timeAnalysisEntry.setLastRank(context.getRank());\r
}\r
refreshViewer(false);\r
}\r
+ if (context != null) {\r
+ context.dispose();\r
+ }\r
}\r
\r
private void refreshViewer(boolean resetTimeIntervals) {\r
return;\r
}\r
synchronized (fSyncObj) {\r
- if (fRefreshBusy) {\r
- fRefreshPending = true;\r
- return;\r
- } else {\r
- fRefreshBusy = true;\r
- }\r
+ if (fRefreshBusy) {\r
+ fRefreshPending = true;\r
+ return;\r
+ } else {\r
+ fRefreshBusy = true;\r
+ }\r
}\r
final boolean reset = resetTimeIntervals;\r
// Perform the refresh on the UI thread\r
Display.getDefault().asyncExec(new Runnable() {\r
@Override\r
public void run() {\r
- if (fComposite.isDisposed()) return;\r
+ if (fComposite.isDisposed())\r
+ return;\r
fViewer.display(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));\r
if (reset) {\r
fViewer.resetStartFinishTime();\r
}\r
synchronized (fSyncObj) {\r
- fRefreshBusy = false;\r
- if (fRefreshPending) {\r
- fRefreshPending = false;\r
- refreshViewer(reset);\r
- }\r
+ fRefreshBusy = false;\r
+ if (fRefreshPending) {\r
+ fRefreshPending = false;\r
+ refreshViewer(reset);\r
+ }\r
}\r
}\r
});\r
}\r
- \r
+\r
private void itemize(long startTime, long stopTime) {\r
for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {\r
Thread thread = new ItemizeThread(fTimeAnalysisEntries.get(i), startTime, stopTime);\r
thread.start();\r
}\r
}\r
- \r
+\r
private class ItemizeThread extends Thread {\r
\r
- private TimeChartAnalysisEntry fTimeAnalysisEntry;\r
- private long fStartTime;\r
- private long fStopTime;\r
- private long fMaxDuration;\r
- \r
+ private final TimeChartAnalysisEntry fTimeAnalysisEntry;\r
+ private final long fStartTime;\r
+ private final long fStopTime;\r
+ private final long fMaxDuration;\r
+\r
private ItemizeThread(TimeChartAnalysisEntry timeAnalysisEntry, long startTime, long stopTime) {\r
- super("Itemize Thread:"+timeAnalysisEntry.getName()); //$NON-NLS-1$\r
+ super("Itemize Thread:" + timeAnalysisEntry.getName()); //$NON-NLS-1$\r
fTimeAnalysisEntry = timeAnalysisEntry;\r
fStartTime = startTime;\r
fStopTime = stopTime;\r
- fMaxDuration = 3 * (fStopTime - fStartTime) / fDisplayWidth;\r
+ fMaxDuration = 3 * (fStopTime - fStartTime) / fDisplayWidth;\r
}\r
- \r
+\r
@Override\r
public void run() {\r
itemizeTraceEntry(fTimeAnalysisEntry);\r
synchronized (timeAnalysisEntry) {\r
while (hasNext = iterator.hasNext()) {\r
event = (TimeChartEvent) iterator.next();\r
- if (event.getTime() + event.getDuration() > fStartTime &&\r
- event.getTime() < fStopTime &&\r
- event.getDuration() > fMaxDuration &&\r
- event.getNbEvents() > 1) {\r
+ if (event.getTime() + event.getDuration() > fStartTime && event.getTime() < fStopTime && event.getDuration() > fMaxDuration\r
+ && event.getNbEvents() > 1) {\r
break;\r
}\r
}\r
}\r
event.setItemizing(true);\r
}\r
- TimeChartAnalysisEntry timeAnalysisEntry = new TimeChartAnalysisEntry(fTimeAnalysisEntry.getTrace(),\r
- (int) Math.min(event.getNbEvents() + 1, fDisplayWidth * 2));\r
+ TimeChartAnalysisEntry timeAnalysisEntry = new TimeChartAnalysisEntry(fTimeAnalysisEntry.getTrace(), (int) Math.min(\r
+ event.getNbEvents() + 1, fDisplayWidth * 2));\r
synchronized (event.getRankRangeList()) {\r
- for (RankRange range : event.getRankRangeList()) {\r
- timeAnalysisEntry.setLastRank(range.getFirstRank());\r
- updateTraceEntry(timeAnalysisEntry, range.getLastRank() + 1, event.getTime(), event.getTime() + event.getDuration());\r
- }\r
+ for (RankRange range : event.getRankRangeList()) {\r
+ timeAnalysisEntry.setLastRank(range.getFirstRank());\r
+ updateTraceEntry(timeAnalysisEntry, range.getLastRank() + 1, event.getTime(), event.getTime() + event.getDuration());\r
+ }\r
}\r
event.setItemizedEntry(timeAnalysisEntry);\r
refreshViewer(false);\r
}\r
\r
private void redecorate() {\r
- synchronized (fDecorateThreads) {\r
- for (DecorateThread thread : fDecorateThreads) {\r
- thread.cancel();\r
- }\r
- fDecorateThreads.clear();\r
- for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {\r
- DecorateThread thread = new DecorateThread(fTimeAnalysisEntries.get(i));\r
- thread.start();\r
- fDecorateThreads.add(thread);\r
- }\r
+ synchronized (fDecorateThreads) {\r
+ for (DecorateThread thread : fDecorateThreads) {\r
+ thread.cancel();\r
+ }\r
+ fDecorateThreads.clear();\r
+ for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {\r
+ DecorateThread thread = new DecorateThread(fTimeAnalysisEntries.get(i));\r
+ thread.start();\r
+ fDecorateThreads.add(thread);\r
+ }\r
}\r
}\r
- \r
+\r
private class DecorateThread extends Thread {\r
- private volatile boolean interrupted = false;\r
- private TimeChartAnalysisEntry fTimeAnalysisEntry;\r
- private TimeChartDecorationProvider fDecorationProvider;\r
+ private volatile boolean interrupted = false;\r
+ private final TimeChartAnalysisEntry fTimeAnalysisEntry;\r
+ private final TimeChartDecorationProvider fDecorationProvider;\r
private TmfContext fContext;\r
private int fCount = 0;\r
- \r
+\r
private DecorateThread(TimeChartAnalysisEntry timeAnalysisEntry) {\r
- super("Decorate Thread:"+timeAnalysisEntry.getName()); //$NON-NLS-1$\r
+ super("Decorate Thread:" + timeAnalysisEntry.getName()); //$NON-NLS-1$\r
fTimeAnalysisEntry = timeAnalysisEntry;\r
fDecorationProvider = fDecorationProviders.get(timeAnalysisEntry.getTrace());\r
}\r
- \r
+\r
@Override\r
public void run() {\r
- resetTraceEntry(fTimeAnalysisEntry);\r
+ resetTraceEntry(fTimeAnalysisEntry);\r
refreshViewer(false);\r
decorateTraceEntry(fTimeAnalysisEntry, null);\r
refreshViewer(false);\r
- synchronized (fDecorateThreads) {\r
- fDecorateThreads.remove(this);\r
- }\r
+ synchronized (fDecorateThreads) {\r
+ fDecorateThreads.remove(this);\r
+ }\r
}\r
\r
public void resetTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry) {\r
}\r
}\r
if (hasNext) {\r
- // TODO possible concurrency problem here with ItemizeJob\r
- event.setColorSettingPriority(ColorSettingsManager.PRIORITY_NONE);\r
+ // TODO possible concurrency problem here with ItemizeJob\r
+ event.setColorSettingPriority(ColorSettingsManager.PRIORITY_NONE);\r
if (event.getItemizedEntry() != null) {\r
- resetTraceEntry(event.getItemizedEntry());\r
+ resetTraceEntry(event.getItemizedEntry());\r
}\r
}\r
}\r
}\r
- \r
+\r
public void decorateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry, TimeChartEvent parentEvent) {\r
- // Set max duration high to ensure iterator does not consider itemized events\r
+ // Set max duration high to ensure iterator does not consider\r
+ // itemized events\r
Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTraceEventsIterator(0, Long.MAX_VALUE, Long.MAX_VALUE);\r
TimeChartEvent event = null;\r
int entryPriority = ColorSettingsManager.PRIORITY_NONE;\r
}\r
}\r
if (hasNext) {\r
- // TODO possible concurrency problem here with ItemizeJob\r
+ // TODO possible concurrency problem here with ItemizeJob\r
if (event.getItemizedEntry() == null) {\r
decorateEvent(event);\r
} else {\r
}\r
}\r
if (parentEvent != null) {\r
- parentEvent.setColorSettingPriority(entryPriority);\r
- parentEvent.setIsBookmarked(entryIsBookmarked);\r
- parentEvent.setIsVisible(entryIsVisible);\r
- parentEvent.setIsSearchMatch(entryIsSearchMatch);\r
+ parentEvent.setColorSettingPriority(entryPriority);\r
+ parentEvent.setIsBookmarked(entryIsBookmarked);\r
+ parentEvent.setIsVisible(entryIsVisible);\r
+ parentEvent.setIsSearchMatch(entryIsSearchMatch);\r
}\r
}\r
\r
public void decorateEvent(TimeChartEvent timeChartEvent) {\r
- // TODO possible concurrency problem here with ItemizeJob\r
- TimeChartAnalysisEntry timeAnalysisEntry = (TimeChartAnalysisEntry) timeChartEvent.getEntry();\r
- ITmfTrace trace = timeAnalysisEntry.getTrace();\r
- int priority = ColorSettingsManager.PRIORITY_NONE;\r
- boolean isBookmarked = false;\r
- boolean isVisible = false;\r
- boolean isSearchMatch = false;\r
+ // TODO possible concurrency problem here with ItemizeJob\r
+ TimeChartAnalysisEntry timeAnalysisEntry = (TimeChartAnalysisEntry) timeChartEvent.getEntry();\r
+ ITmfTrace trace = timeAnalysisEntry.getTrace();\r
+ int priority = ColorSettingsManager.PRIORITY_NONE;\r
+ boolean isBookmarked = false;\r
+ boolean isVisible = false;\r
+ boolean isSearchMatch = false;\r
synchronized (timeChartEvent.getRankRangeList()) {\r
- for (RankRange range : timeChartEvent.getRankRangeList()) {\r
- if (interrupted) return;\r
- if (fContext == null || fContext.getRank() != range.getFirstRank()) {\r
- fContext = trace.seekEvent(range.getFirstRank());\r
- fContext.setRank(range.getFirstRank());\r
- }\r
+ for (RankRange range : timeChartEvent.getRankRangeList()) {\r
+ if (interrupted)\r
+ return;\r
+ if (fContext == null || fContext.getRank() != range.getFirstRank()) {\r
+ fContext = trace.seekEvent(range.getFirstRank());\r
+ fContext.setRank(range.getFirstRank());\r
+ }\r
while (true) {\r
- if (interrupted) return;\r
- long rank = fContext.getRank();\r
+ if (interrupted)\r
+ return;\r
+ long rank = fContext.getRank();\r
TmfEvent event = trace.getNextEvent(fContext);\r
if (event == null) {\r
break;\r
}\r
long eventTime = event.getTimestamp().synchronize(0, (byte) -9).getValue();\r
if (eventTime >= timeChartEvent.getTime() && eventTime <= timeChartEvent.getTime() + timeChartEvent.getDuration()) {\r
- priority = Math.min(priority, ColorSettingsManager.getColorSettingPriority(event));\r
+ priority = Math.min(priority, ColorSettingsManager.getColorSettingPriority(event));\r
}\r
- isBookmarked |= fDecorationProvider.isBookmark(rank); \r
- isVisible |= fDecorationProvider.isVisible(event); \r
- isSearchMatch |= fDecorationProvider.isSearchMatch(event); \r
+ isBookmarked |= fDecorationProvider.isBookmark(rank);\r
+ isVisible |= fDecorationProvider.isVisible(event);\r
+ isSearchMatch |= fDecorationProvider.isSearchMatch(event);\r
if (fContext.getRank() > range.getLastRank()) {\r
- break;\r
+ break;\r
}\r
}\r
- }\r
+ }\r
}\r
timeChartEvent.setColorSettingPriority(priority);\r
timeChartEvent.setIsBookmarked(isBookmarked);\r
timeChartEvent.setIsVisible(isVisible);\r
timeChartEvent.setIsSearchMatch(isSearchMatch);\r
}\r
- \r
- public void cancel() {\r
- interrupted = true;\r
- }\r
+\r
+ public void cancel() {\r
+ interrupted = true;\r
+ }\r
}\r
\r
// ------------------------------------------------------------------------\r
// Listeners\r
// ------------------------------------------------------------------------\r
- \r
+\r
@Override\r
public void tsfTmProcessTimeScaleEvent(TmfTimeScaleSelectionEvent event) {\r
- fStartTime = event.getTime0();\r
- fStopTime = event.getTime1();\r
+ fStartTime = event.getTime0();\r
+ fStopTime = event.getTime1();\r
itemize(fStartTime, fStopTime);\r
}\r
\r
broadcast(new TmfTimeSynchSignal(this, new TmfTimestamp(event.getSelectedTime(), TIMESTAMP_SCALE)));\r
}\r
\r
- @Override\r
+ @Override\r
public void colorSettingsChanged(ColorSetting[] colorSettings) {\r
- redecorate();\r
+ redecorate();\r
}\r
\r
@Override\r
public void resourceChanged(IResourceChangeEvent event) {\r
- for (IMarkerDelta delta : event.findMarkerDeltas(IMarker.BOOKMARK, false)) {\r
- for (TimeChartDecorationProvider provider : fDecorationProviders.values()) {\r
- if (delta.getResource().equals(provider.getResource())) {\r
- if (delta.getKind() == IResourceDelta.CHANGED && delta.getMarker().getAttribute(IMarker.LOCATION, -1) != -1) {\r
- provider.refreshBookmarks();\r
- } else if (delta.getKind() == IResourceDelta.REMOVED) {\r
- provider.refreshBookmarks();\r
- }\r
- }\r
- }\r
- }\r
- redecorate();\r
+ for (IMarkerDelta delta : event.findMarkerDeltas(IMarker.BOOKMARK, false)) {\r
+ for (TimeChartDecorationProvider provider : fDecorationProviders.values()) {\r
+ if (delta.getResource().equals(provider.getResource())) {\r
+ if (delta.getKind() == IResourceDelta.CHANGED && delta.getMarker().getAttribute(IMarker.LOCATION, -1) != -1) {\r
+ provider.refreshBookmarks();\r
+ } else if (delta.getKind() == IResourceDelta.REMOVED) {\r
+ provider.refreshBookmarks();\r
+ }\r
+ }\r
+ }\r
+ }\r
+ redecorate();\r
}\r
- \r
- @Override\r
+\r
+ @Override\r
public void filterApplied(ITmfFilter filter, ITmfTrace trace) {\r
- TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(trace);\r
- decorationProvider.filterApplied(filter);\r
- redecorate();\r
+ TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(trace);\r
+ decorationProvider.filterApplied(filter);\r
+ redecorate();\r
}\r
\r
- @Override\r
+ @Override\r
public void searchApplied(ITmfFilter filter, ITmfTrace trace) {\r
- TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(trace);\r
- decorationProvider.searchApplied(filter);\r
- redecorate();\r
+ TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(trace);\r
+ decorationProvider.searchApplied(filter);\r
+ redecorate();\r
}\r
\r
// ------------------------------------------------------------------------\r
// Signal handlers\r
// ------------------------------------------------------------------------\r
- \r
- @TmfSignalHandler\r
+\r
+ @TmfSignalHandler\r
public void traceOpened(TmfTraceOpenedSignal signal) {\r
- if (fTimeAnalysisEntries == null) return;\r
+ if (fTimeAnalysisEntries == null)\r
+ return;\r
final ITmfTrace trace = signal.getTrace();\r
final IResource resource = signal.getResource();\r
final ITmfEventsFilterProvider eventsFilterProvider = signal.getEventsFilterProvider();\r
}\r
}\r
if (timeAnalysisEntry == null) {\r
- timeAnalysisEntry = new TimeChartAnalysisEntry(trace, fDisplayWidth * 2); \r
+ timeAnalysisEntry = new TimeChartAnalysisEntry(trace, fDisplayWidth * 2);\r
fTimeAnalysisEntries.add(timeAnalysisEntry);\r
fDecorationProviders.put(trace, new TimeChartDecorationProvider(resource));\r
Thread thread = new ProcessTraceThread(timeAnalysisEntry);\r
}\r
refreshViewer(true);\r
if (eventsFilterProvider != null) {\r
- eventsFilterProvider.addEventsFilterListener(this);\r
+ eventsFilterProvider.addEventsFilterListener(this);\r
}\r
}\r
- \r
+\r
@TmfSignalHandler\r
public void traceClosed(TmfTraceClosedSignal signal) {\r
- if (fTimeAnalysisEntries == null) return;\r
+ if (fTimeAnalysisEntries == null)\r
+ return;\r
final ITmfTrace trace = signal.getTrace();\r
for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {\r
if (fTimeAnalysisEntries.get(i).getTrace().equals(trace)) {\r
}\r
}\r
}\r
- \r
+\r
@TmfSignalHandler\r
public void traceSelected(TmfTraceSelectedSignal signal) {\r
if (signal.getSource() != this && fTimeAnalysisEntries != null) {\r
\r
@TmfSignalHandler\r
public void traceUpdated(TmfTraceUpdatedSignal signal) {\r
- if (fTimeAnalysisEntries == null) return;\r
+ if (fTimeAnalysisEntries == null)\r
+ return;\r
final ITmfTrace trace = signal.getTrace();\r
for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {\r
TimeChartAnalysisEntry timeAnalysisEntry = fTimeAnalysisEntries.get(i);\r
* This abstract class implements the housekeeking methods to register/
* deregister the event provider and to handle generically the event requests.
* <p>
- * The concrete class can either re-implement processRequest() entirely or
- * just implement the hooks (initializeContext() and getNext()).
+ * The concrete class can either re-implement processRequest() entirely or just
+ * implement the hooks (initializeContext() and getNext()).
* <p>
* TODO: Add support for providing multiple data types.
*/
public abstract class TmfDataProvider<T extends TmfData> extends TmfComponent implements ITmfDataProvider<T> {
- // ------------------------------------------------------------------------
- // Constants
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
+ // Constants
+ // ------------------------------------------------------------------------
// private static final ITmfDataRequest.ExecutionType SHORT = ITmfDataRequest.ExecutionType.SHORT;
// private static final ITmfDataRequest.ExecutionType LONG = ITmfDataRequest.ExecutionType.LONG;
-
- // ------------------------------------------------------------------------
- //
- // ------------------------------------------------------------------------
- final protected Class<T> fType;
- final protected boolean fLogData;
- final protected boolean fLogError;
+ // ------------------------------------------------------------------------
+ //
+ // ------------------------------------------------------------------------
- public static final int DEFAULT_BLOCK_SIZE = 50000;
- public static final int DEFAULT_QUEUE_SIZE = 1000;
+ final protected Class<T> fType;
+ final protected boolean fLogData;
+ final protected boolean fLogError;
- protected final int fQueueSize;
- protected final BlockingQueue<T> fDataQueue;
- protected final TmfRequestExecutor fExecutor;
+ public static final int DEFAULT_BLOCK_SIZE = 50000;
+ public static final int DEFAULT_QUEUE_SIZE = 1000;
- private int fSignalDepth = 0;
+ protected final int fQueueSize;
+ protected final BlockingQueue<T> fDataQueue;
+ protected final TmfRequestExecutor fExecutor;
+
+ private int fSignalDepth = 0;
private final Object fLock = new Object();
private int fRequestPendingCounter = 0;
- // ------------------------------------------------------------------------
- // Constructors
- // ------------------------------------------------------------------------
-
- public TmfDataProvider(String name, Class<T> type) {
- this(name, type, DEFAULT_QUEUE_SIZE);
- }
-
- protected TmfDataProvider(String name, Class<T> type, int queueSize) {
- super(name);
- fType = type;
- fQueueSize = queueSize;
+ // ------------------------------------------------------------------------
+ // Constructors
+ // ------------------------------------------------------------------------
+
+ public TmfDataProvider(String name, Class<T> type) {
+ this(name, type, DEFAULT_QUEUE_SIZE);
+ }
+
+ protected TmfDataProvider(String name, Class<T> type, int queueSize) {
+ super(name);
+ fType = type;
+ fQueueSize = queueSize;
fDataQueue = (fQueueSize > 1) ? new LinkedBlockingQueue<T>(fQueueSize) : new SynchronousQueue<T>();
fExecutor = new TmfRequestExecutor();
- fSignalDepth = 0;
+ fSignalDepth = 0;
- fLogData = Tracer.isEventTraced();
- fLogError = Tracer.isErrorTraced();
+ fLogData = Tracer.isEventTraced();
+ fLogError = Tracer.isErrorTraced();
- TmfProviderManager.register(fType, this);
+ TmfProviderManager.register(fType, this);
// if (Tracer.isComponentTraced()) Tracer.traceComponent(this, "started");
-}
-
- public TmfDataProvider(TmfDataProvider<T> other) {
+ }
+
+ public TmfDataProvider(TmfDataProvider<T> other) {
super(other);
fType = other.fType;
fQueueSize = other.fQueueSize;
fExecutor = new TmfRequestExecutor();
fSignalDepth = 0;
- fLogData = Tracer.isEventTraced();
+ fLogData = Tracer.isEventTraced();
fLogError = Tracer.isErrorTraced();
- }
-
- @Override
- public void dispose() {
- TmfProviderManager.deregister(fType, this);
- fExecutor.stop();
- super.dispose();
+ }
+
+ @Override
+ public void dispose() {
+ TmfProviderManager.deregister(fType, this);
+ fExecutor.stop();
+ super.dispose();
// if (Tracer.isComponentTraced()) Tracer.traceComponent(this, "stopped");
- }
-
- public int getQueueSize() {
- return fQueueSize;
- }
-
- public Class<?> getType() {
- return fType;
- }
-
- // ------------------------------------------------------------------------
- // ITmfRequestHandler
- // ------------------------------------------------------------------------
-
- @Override
- public void sendRequest(final ITmfDataRequest<T> request) {
- synchronized(fLock) {
- if (fSignalDepth > 0) {
- coalesceDataRequest(request);
- } else {
- dispatchRequest(request);
- }
- }
- }
-
- /**
- * This method queues the coalesced requests.
- *
- * @param thread
- */
- @Override
+ }
+
+ public int getQueueSize() {
+ return fQueueSize;
+ }
+
+ public Class<?> getType() {
+ return fType;
+ }
+
+ // ------------------------------------------------------------------------
+ // ITmfRequestHandler
+ // ------------------------------------------------------------------------
+
+ @Override
+ public void sendRequest(final ITmfDataRequest<T> request) {
+ synchronized (fLock) {
+ if (fSignalDepth > 0) {
+ coalesceDataRequest(request);
+ } else {
+ dispatchRequest(request);
+ }
+ }
+ }
+
+ /**
+ * This method queues the coalesced requests.
+ *
+ * @param thread
+ */
+ @Override
public void fireRequest() {
- synchronized(fLock) {
- if (fRequestPendingCounter > 0) {
- return;
- }
- if (fPendingCoalescedRequests.size() > 0) {
- for (TmfDataRequest<T> request : fPendingCoalescedRequests) {
- dispatchRequest(request);
- }
- fPendingCoalescedRequests.clear();
- }
- }
- }
-
- /**
- * Increments/decrements the pending requests counters and fires
- * the request if necessary (counter == 0). Used for coalescing
- * requests accross multiple TmfDataProvider.
- *
- * @param isIncrement
- */
+ synchronized (fLock) {
+ if (fRequestPendingCounter > 0) {
+ return;
+ }
+ if (fPendingCoalescedRequests.size() > 0) {
+ for (TmfDataRequest<T> request : fPendingCoalescedRequests) {
+ dispatchRequest(request);
+ }
+ fPendingCoalescedRequests.clear();
+ }
+ }
+ }
+
+ /**
+ * Increments/decrements the pending requests counters and fires the request
+ * if necessary (counter == 0). Used for coalescing requests accross
+ * multiple TmfDataProvider.
+ *
+ * @param isIncrement
+ */
@Override
public void notifyPendingRequest(boolean isIncrement) {
- synchronized(fLock) {
+ synchronized (fLock) {
if (isIncrement) {
if (fSignalDepth > 0) {
fRequestPendingCounter++;
if (fRequestPendingCounter > 0) {
fRequestPendingCounter--;
}
-
+
// fire request if all pending requests are received
if (fRequestPendingCounter == 0) {
fireRequest();
}
}
}
- }
-
- // ------------------------------------------------------------------------
- // Coalescing (primitive test...)
- // ------------------------------------------------------------------------
-
- protected Vector<TmfCoalescedDataRequest<T>> fPendingCoalescedRequests = new Vector<TmfCoalescedDataRequest<T>>();
-
- protected void newCoalescedDataRequest(ITmfDataRequest<T> request) {
- synchronized(fLock) {
- TmfCoalescedDataRequest<T> coalescedRequest = new TmfCoalescedDataRequest<T>(
- fType, request.getIndex(), request.getNbRequested(), request.getBlockSize(), request.getExecType());
- coalescedRequest.addRequest(request);
- if (Tracer.isRequestTraced()) {
- Tracer.traceRequest(request, "coalesced with " + coalescedRequest.getRequestId()); //$NON-NLS-1$
- }
- fPendingCoalescedRequests.add(coalescedRequest);
- }
- }
-
- protected void coalesceDataRequest(ITmfDataRequest<T> request) {
- synchronized(fLock) {
- for (TmfCoalescedDataRequest<T> coalescedRequest : fPendingCoalescedRequests) {
- if (coalescedRequest.isCompatible(request)) {
- coalescedRequest.addRequest(request);
- if (Tracer.isRequestTraced()) {
- Tracer.traceRequest(request, "coalesced with " + coalescedRequest.getRequestId()); //$NON-NLS-1$
- }
- return;
- }
- }
- newCoalescedDataRequest(request);
- }
- }
-
- // ------------------------------------------------------------------------
- // Request processing
- // ------------------------------------------------------------------------
-
- private void dispatchRequest(final ITmfDataRequest<T> request) {
- if (request.getExecType() == ExecutionType.FOREGROUND)
- queueRequest(request);
- else
- queueBackgroundRequest(request, request.getBlockSize(), true);
- }
-
- protected void queueRequest(final ITmfDataRequest<T> request) {
-
- if (fExecutor.isShutdown()) {
- request.cancel();
- return;
- }
-
- final TmfDataProvider<T> provider = this;
-
- // Process the request
- TmfThread thread = new TmfThread(request.getExecType()) {
-
- @Override
- public void run() {
-
- if (Tracer.isRequestTraced()) Tracer.trace("Request #" + request.getRequestId() + " is being serviced by " + provider.getName()); //$NON-NLS-1$//$NON-NLS-2$
-
- // Extract the generic information
- request.start();
- int nbRequested = request.getNbRequested();
- int nbRead = 0;
-
- // Initialize the execution
- ITmfContext context = armRequest(request);
- if (context == null) {
- request.cancel();
- return;
- }
-
- try {
- // Get the ordered events
- T data = getNext(context);
- if (Tracer.isRequestTraced()) Tracer.trace("Request #" + request.getRequestId() + " read first event"); //$NON-NLS-1$ //$NON-NLS-2$
- while (data != null && !isCompleted(request, data, nbRead))
- {
- if (fLogData) Tracer.traceEvent(provider, request, data);
- request.handleData(data);
-
- // To avoid an unnecessary read passed the last data requested
- if (++nbRead < nbRequested) {
- data = getNext(context);
- }
- }
- if (Tracer.isRequestTraced()) Tracer.trace("Request #" + request.getRequestId() + " finished"); //$NON-NLS-1$//$NON-NLS-2$
-
- if (request.isCancelled()) {
- request.cancel();
- }
- else {
- request.done();
- }
- }
- catch (Exception e) {
- request.fail();
- }
- }
- };
-
- if (Tracer.isRequestTraced()) Tracer.traceRequest(request, "queued"); //$NON-NLS-1$
- fExecutor.execute(thread);
-
- }
-
- protected void queueBackgroundRequest(final ITmfDataRequest<T> request, final int blockSize, final boolean indexing) {
-
- Thread thread = new Thread() {
- @Override
- public void run() {
- request.start();
-
- final Integer[] CHUNK_SIZE = new Integer[1];
- CHUNK_SIZE[0] = Math.min(request.getNbRequested(), blockSize + ((indexing) ? 1 : 0));
-
- final Integer[] nbRead = new Integer[1];
- nbRead[0] = 0;
-
- final Boolean[] isFinished = new Boolean[1];
- isFinished[0] = Boolean.FALSE;
-
- while (!isFinished[0]) {
-
- TmfDataRequest<T> subRequest= new TmfDataRequest<T>(request.getDataType(), request.getIndex() + nbRead[0], CHUNK_SIZE[0], blockSize, ExecutionType.BACKGROUND)
- {
- @Override
- public void handleData(T data) {
- super.handleData(data);
- request.handleData(data);
- if (getNbRead() > CHUNK_SIZE[0]) {
- System.out.println("ERROR - Read too many events"); //$NON-NLS-1$
- }
- }
-
- @Override
- public void handleCompleted() {
- nbRead[0] += getNbRead();
- if (nbRead[0] >= request.getNbRequested() || (getNbRead() < CHUNK_SIZE[0])) {
- if (isCancelled()) {
- request.cancel();
- }
- else {
- request.done();
- }
- isFinished[0] = Boolean.TRUE;
- }
- super.handleCompleted();
- }
- };
-
- if (!isFinished[0]) {
- queueRequest(subRequest);
-
- try {
- subRequest.waitForCompletion();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
-
- CHUNK_SIZE[0] = Math.min(request.getNbRequested() - nbRead[0], blockSize);
- }
- }
- }
- };
-
- thread.start();
- }
-
- /**
- * Initialize the provider based on the request. The context is
- * provider specific and will be updated by getNext().
- *
- * @param request
- * @return an application specific context; null if request can't be serviced
- */
- public abstract ITmfContext armRequest(ITmfDataRequest<T> request);
- public abstract T getNext(ITmfContext context);
-
- /**
- * Checks if the data meets the request completion criteria.
- *
- * @param request
- * @param data
- * @return
- */
- public boolean isCompleted(ITmfDataRequest<T> request, T data, int nbRead) {
- return request.isCompleted() || nbRead >= request.getNbRequested() || data.isNullRef();
- }
-
- // ------------------------------------------------------------------------
- // Signal handlers
- // ------------------------------------------------------------------------
-
- @TmfSignalHandler
- public void startSynch(TmfStartSynchSignal signal) {
- synchronized (fLock) {
- fSignalDepth++;
- }
- }
-
- @TmfSignalHandler
- public void endSynch(TmfEndSynchSignal signal) {
+ }
+
+ // ------------------------------------------------------------------------
+ // Coalescing (primitive test...)
+ // ------------------------------------------------------------------------
+
+ protected Vector<TmfCoalescedDataRequest<T>> fPendingCoalescedRequests = new Vector<TmfCoalescedDataRequest<T>>();
+
+ protected void newCoalescedDataRequest(ITmfDataRequest<T> request) {
+ synchronized (fLock) {
+ TmfCoalescedDataRequest<T> coalescedRequest = new TmfCoalescedDataRequest<T>(fType, request.getIndex(), request.getNbRequested(),
+ request.getBlockSize(), request.getExecType());
+ coalescedRequest.addRequest(request);
+ if (Tracer.isRequestTraced()) {
+ Tracer.traceRequest(request, "coalesced with " + coalescedRequest.getRequestId()); //$NON-NLS-1$
+ }
+ fPendingCoalescedRequests.add(coalescedRequest);
+ }
+ }
+
+ protected void coalesceDataRequest(ITmfDataRequest<T> request) {
+ synchronized (fLock) {
+ for (TmfCoalescedDataRequest<T> coalescedRequest : fPendingCoalescedRequests) {
+ if (coalescedRequest.isCompatible(request)) {
+ coalescedRequest.addRequest(request);
+ if (Tracer.isRequestTraced()) {
+ Tracer.traceRequest(request, "coalesced with " + coalescedRequest.getRequestId()); //$NON-NLS-1$
+ }
+ return;
+ }
+ }
+ newCoalescedDataRequest(request);
+ }
+ }
+
+ // ------------------------------------------------------------------------
+ // Request processing
+ // ------------------------------------------------------------------------
+
+ private void dispatchRequest(final ITmfDataRequest<T> request) {
+ if (request.getExecType() == ExecutionType.FOREGROUND)
+ queueRequest(request);
+ else
+ queueBackgroundRequest(request, request.getBlockSize(), true);
+ }
+
+ protected void queueRequest(final ITmfDataRequest<T> request) {
+
+ if (fExecutor.isShutdown()) {
+ request.cancel();
+ return;
+ }
+
+ final TmfDataProvider<T> provider = this;
+
+ // Process the request
+ TmfThread thread = new TmfThread(request.getExecType()) {
+
+ @Override
+ public void run() {
+
+ if (Tracer.isRequestTraced())
+ Tracer.trace("Request #" + request.getRequestId() + " is being serviced by " + provider.getName()); //$NON-NLS-1$//$NON-NLS-2$
+
+ // Extract the generic information
+ request.start();
+ int nbRequested = request.getNbRequested();
+ int nbRead = 0;
+
+ // Initialize the execution
+ ITmfContext context = armRequest(request);
+ if (context == null) {
+ request.cancel();
+ return;
+ }
+
+ try {
+ // Get the ordered events
+ T data = getNext(context);
+ if (Tracer.isRequestTraced())
+ Tracer.trace("Request #" + request.getRequestId() + " read first event"); //$NON-NLS-1$ //$NON-NLS-2$
+ while (data != null && !isCompleted(request, data, nbRead)) {
+ if (fLogData)
+ Tracer.traceEvent(provider, request, data);
+ request.handleData(data);
+
+ // To avoid an unnecessary read passed the last data
+ // requested
+ if (++nbRead < nbRequested) {
+ data = getNext(context);
+ }
+ }
+ if (Tracer.isRequestTraced())
+ Tracer.trace("Request #" + request.getRequestId() + " finished"); //$NON-NLS-1$//$NON-NLS-2$
+
+ if (request.isCancelled()) {
+ request.cancel();
+ } else {
+ request.done();
+ }
+ } catch (Exception e) {
+ request.fail();
+ }
+
+ // Cleanup
+ context.dispose();
+ }
+ };
+
+ if (Tracer.isRequestTraced())
+ Tracer.traceRequest(request, "queued"); //$NON-NLS-1$
+ fExecutor.execute(thread);
+
+ }
+
+ protected void queueBackgroundRequest(final ITmfDataRequest<T> request, final int blockSize, final boolean indexing) {
+
+ Thread thread = new Thread() {
+ @Override
+ public void run() {
+ request.start();
+
+ final Integer[] CHUNK_SIZE = new Integer[1];
+ CHUNK_SIZE[0] = Math.min(request.getNbRequested(), blockSize + ((indexing) ? 1 : 0));
+
+ final Integer[] nbRead = new Integer[1];
+ nbRead[0] = 0;
+
+ final Boolean[] isFinished = new Boolean[1];
+ isFinished[0] = Boolean.FALSE;
+
+ while (!isFinished[0]) {
+
+ TmfDataRequest<T> subRequest = new TmfDataRequest<T>(request.getDataType(), request.getIndex() + nbRead[0], CHUNK_SIZE[0],
+ blockSize, ExecutionType.BACKGROUND) {
+ @Override
+ public void handleData(T data) {
+ super.handleData(data);
+ request.handleData(data);
+ if (getNbRead() > CHUNK_SIZE[0]) {
+ System.out.println("ERROR - Read too many events"); //$NON-NLS-1$
+ }
+ }
+
+ @Override
+ public void handleCompleted() {
+ nbRead[0] += getNbRead();
+ if (nbRead[0] >= request.getNbRequested() || (getNbRead() < CHUNK_SIZE[0])) {
+ if (isCancelled()) {
+ request.cancel();
+ } else {
+ request.done();
+ }
+ isFinished[0] = Boolean.TRUE;
+ }
+ super.handleCompleted();
+ }
+ };
+
+ if (!isFinished[0]) {
+ queueRequest(subRequest);
+
+ try {
+ subRequest.waitForCompletion();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+
+ CHUNK_SIZE[0] = Math.min(request.getNbRequested() - nbRead[0], blockSize);
+ }
+ }
+ }
+ };
+
+ thread.start();
+ }
+
+ /**
+ * Initialize the provider based on the request. The context is provider
+ * specific and will be updated by getNext().
+ *
+ * @param request
+ * @return an application specific context; null if request can't be
+ * serviced
+ */
+ public abstract ITmfContext armRequest(ITmfDataRequest<T> request);
+
+ public abstract T getNext(ITmfContext context);
+
+ /**
+ * Checks if the data meets the request completion criteria.
+ *
+ * @param request
+ * @param data
+ * @return
+ */
+ public boolean isCompleted(ITmfDataRequest<T> request, T data, int nbRead) {
+ return request.isCompleted() || nbRead >= request.getNbRequested() || data.isNullRef();
+ }
+
+ // ------------------------------------------------------------------------
+ // Signal handlers
+ // ------------------------------------------------------------------------
+
+ @TmfSignalHandler
+ public void startSynch(TmfStartSynchSignal signal) {
+ synchronized (fLock) {
+ fSignalDepth++;
+ }
+ }
+
+ @TmfSignalHandler
+ public void endSynch(TmfEndSynchSignal signal) {
synchronized (fLock) {
- fSignalDepth--;
- if (fSignalDepth == 0) {
- fireRequest();
- }
+ fSignalDepth--;
+ if (fSignalDepth == 0) {
+ fireRequest();
+ }
}
- }
+ }
}
*/
public interface ITmfContext {
- public long UNKNOWN_RANK = -2L;
+ public long UNKNOWN_RANK = -2L;
public long INITIAL_RANK = -1L;
- public void setLocation(ITmfLocation<?> location);
- @SuppressWarnings("rawtypes")
- public ITmfLocation<? extends Comparable> getLocation();
+ public void dispose();
- public void setRank(long rank);
- public long getRank();
- public void updateRank(int rank);
+ public void setLocation(ITmfLocation<?> location);
- public boolean isValidRank();
+ @SuppressWarnings("rawtypes")
+ public ITmfLocation<? extends Comparable> getLocation();
+
+ public void setRank(long rank);
+
+ public long getRank();
+
+ public void updateRank(int rank);
+
+ public boolean isValidRank();
}
package org.eclipse.linuxtools.tmf.trace;
-
/**
* <b><u>TmfContext</u></b>
* <p>
*/
public class TmfContext implements ITmfContext, Cloneable {
- private ITmfLocation<? extends Comparable<?>> fLocation;
- private long fRank;
-
- // ------------------------------------------------------------------------
- // Constructors
- // ------------------------------------------------------------------------
-
- public TmfContext(ITmfLocation<? extends Comparable<?>> loc, long rank) {
- fLocation = loc;
- fRank = rank;
- }
-
- public TmfContext(ITmfLocation<? extends Comparable<?>> location) {
- this(location, UNKNOWN_RANK);
- }
-
- public TmfContext(TmfContext other) {
- this(other.fLocation, other.fRank);
- }
-
- public TmfContext() {
- this(null, UNKNOWN_RANK);
- }
-
- // ------------------------------------------------------------------------
- // ITmfContext
- // ------------------------------------------------------------------------
-
- @Override
- public void setLocation(ITmfLocation<? extends Comparable<?>> location) {
- fLocation = location;
- }
-
- @Override
- public ITmfLocation<? extends Comparable<?>> getLocation() {
- return fLocation;
- }
-
- @Override
- public void setRank(long rank) {
- fRank = rank;
- }
-
- @Override
- public long getRank() {
- return fRank;
- }
-
- @Override
- public void updateRank(int delta) {
- if (isValidRank())
- fRank += delta;
- }
-
- @Override
- public boolean isValidRank() {
- return fRank != UNKNOWN_RANK;
- }
-
- // ------------------------------------------------------------------------
- // Object
- // ------------------------------------------------------------------------
+ private ITmfLocation<? extends Comparable<?>> fLocation;
+ private long fRank;
+
+ // ------------------------------------------------------------------------
+ // Constructors
+ // ------------------------------------------------------------------------
+
+ public TmfContext(ITmfLocation<? extends Comparable<?>> loc, long rank) {
+ fLocation = loc;
+ fRank = rank;
+ }
+
+ public TmfContext(ITmfLocation<? extends Comparable<?>> location) {
+ this(location, UNKNOWN_RANK);
+ }
+
+ public TmfContext(TmfContext other) {
+ this(other.fLocation, other.fRank);
+ }
+
+ public TmfContext() {
+ this(null, UNKNOWN_RANK);
+ }
+
+ // ------------------------------------------------------------------------
+ // ITmfContext
+ // ------------------------------------------------------------------------
+
+ @Override
+ public void dispose() {
+ // override if necessary
+ }
+
+ @Override
+ public void setLocation(ITmfLocation<? extends Comparable<?>> location) {
+ fLocation = location;
+ }
+
+ @Override
+ public ITmfLocation<? extends Comparable<?>> getLocation() {
+ return fLocation;
+ }
+
+ @Override
+ public void setRank(long rank) {
+ fRank = rank;
+ }
+
+ @Override
+ public long getRank() {
+ return fRank;
+ }
+
+ @Override
+ public void updateRank(int delta) {
+ if (isValidRank())
+ fRank += delta;
+ }
+
+ @Override
+ public boolean isValidRank() {
+ return fRank != UNKNOWN_RANK;
+ }
+
+ // ------------------------------------------------------------------------
+ // Object
+ // ------------------------------------------------------------------------
@Override
public int hashCode() {
- int result = 17;
- result = 37 * result + fLocation.hashCode();
- result = 37 * result + (int) (fRank ^ (fRank >>> 32));
- return result;
+ int result = 17;
+ result = 37 * result + fLocation.hashCode();
+ result = 37 * result + (int) (fRank ^ (fRank >>> 32));
+ return result;
}
-
+
@Override
public boolean equals(Object other) {
- if (other == this) {
- return true;
- }
- if (!(other instanceof TmfContext)) {
- return false;
- }
- TmfContext o = (TmfContext) other;
- return fLocation.equals(o.fLocation) && (fRank == o.fRank);
+ if (other == this) {
+ return true;
+ }
+ if (!(other instanceof TmfContext)) {
+ return false;
+ }
+ TmfContext o = (TmfContext) other;
+ return fLocation.equals(o.fLocation) && (fRank == o.fRank);
}
-
- @Override
+
+ @Override
@SuppressWarnings("nls")
public String toString() {
- return "[TmfContext(" + fLocation.toString() + "," + fRank + ")]";
+ return "[TmfContext(" + fLocation.toString() + "," + fRank + ")]";
+ }
+
+ @Override
+ public TmfContext clone() {
+ TmfContext clone = null;
+ try {
+ clone = (TmfContext) super.clone();
+ clone.fLocation = fLocation.clone();
+ clone.fRank = fRank;
+ } catch (CloneNotSupportedException e) {
+ }
+ return clone;
}
-
- @Override
- public TmfContext clone() {
- TmfContext clone = null;
- try {
- clone = (TmfContext) super.clone();
- clone.fLocation = fLocation.clone();
- clone.fRank = fRank;
- } catch (CloneNotSupportedException e) {
- }
- return clone;
- }
}
projects / deliverable / tracecompass.git / commitdiff
