package org.eclipse.linuxtools.tmf.core.experiment;
-import java.io.FileNotFoundException;
import java.util.Collections;
import java.util.Vector;
+import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.linuxtools.tmf.core.component.TmfEventProvider;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest;
import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest;
import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;
+import org.eclipse.linuxtools.tmf.core.signal.TmfEndSynchSignal;
import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentDisposedSignal;
import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentRangeUpdatedSignal;
import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentSelectedSignal;
* TmfExperiment presents a time-ordered, unified view of a set of TmfTraces that are part of a tracing experiment.
* <p>
*/
-public class TmfExperiment<T extends TmfEvent> extends TmfEventProvider<T> implements ITmfTrace<T> {
+public class TmfExperiment<T extends ITmfEvent> extends TmfEventProvider<T> implements ITmfTrace<T> {
// ------------------------------------------------------------------------
// Attributes
protected TmfTimeRange fTimeRange;
// The experiment reference timestamp (default: Zero)
- protected TmfTimestamp fEpoch;
+ protected ITmfTimestamp fEpoch;
// The experiment index
protected Vector<TmfCheckpoint> fCheckpoints = new Vector<TmfCheckpoint>();
// The current experiment context
protected TmfExperimentContext fExperimentContext;
+ // Flag to initialize only once
+ private boolean fInitialized = false;
+
+ // The experiment bookmarks file
+ private IFile fBookmarksFile;
+
+ // The properties resource
+ private IResource fResource;
+
// ------------------------------------------------------------------------
// Constructors
// ------------------------------------------------------------------------
}
@Override
- public void initTrace(String path, Class<T> eventType) throws FileNotFoundException {
+ public void initTrace(String name, String path, Class<T> eventType) {
}
@Override
- public void initTrace(String path, Class<T> eventType, boolean indexTrace) throws FileNotFoundException {
+ public void initTrace(String name, String path, Class<T> eventType, boolean indexTrace) {
+ if (indexTrace) {
+ initializeStreamingMonitor();
+ }
}
@Override
- public void initTrace(String path, Class<T> eventType, int cacheSize) throws FileNotFoundException {
+ public void initTrace(String name, String path, Class<T> eventType, int cacheSize) {
}
@Override
- public void initTrace(String path, Class<T> eventType, int cacheSize, boolean indexTrace) throws FileNotFoundException {
+ public void initTrace(String name, String path, Class<T> eventType, int cacheSize, boolean indexTrace) {
+ if (indexTrace) {
+ initializeStreamingMonitor();
+ }
}
/**
* @param epoch
* @param indexPageSize
*/
- public TmfExperiment(Class<T> type, String id, ITmfTrace<T>[] traces, TmfTimestamp epoch, int indexPageSize) {
- this(type, id, traces, TmfTimestamp.Zero, indexPageSize, false);
+ public TmfExperiment(Class<T> type, String id, ITmfTrace<T>[] traces, ITmfTimestamp epoch, int indexPageSize) {
+ this(type, id, traces, TmfTimestamp.ZERO, indexPageSize, false);
}
- public TmfExperiment(Class<T> type, String id, ITmfTrace<T>[] traces, TmfTimestamp epoch, int indexPageSize, boolean preIndexExperiment) {
+ public TmfExperiment(Class<T> type, String id, ITmfTrace<T>[] traces, ITmfTimestamp epoch, int indexPageSize, boolean preIndexExperiment) {
super(id, type);
fTraces = traces;
fEpoch = epoch;
fIndexPageSize = indexPageSize;
- fTimeRange = TmfTimeRange.Null;
-
- if (preIndexExperiment) {
- indexExperiment(true);
- updateTimeRange();
- }
+ fTimeRange = TmfTimeRange.NULL_RANGE;
+ indexExperiment(true);
+ updateTimeRange();
}
protected TmfExperiment(String id, Class<T> type) {
* @param traces
*/
public TmfExperiment(Class<T> type, String id, ITmfTrace<T>[] traces) {
- this(type, id, traces, TmfTimestamp.Zero, DEFAULT_INDEX_PAGE_SIZE);
+ this(type, id, traces, TmfTimestamp.ZERO, DEFAULT_INDEX_PAGE_SIZE);
}
/**
* @param indexPageSize
*/
public TmfExperiment(Class<T> type, String id, ITmfTrace<T>[] traces, int indexPageSize) {
- this(type, id, traces, TmfTimestamp.Zero, indexPageSize);
+ this(type, id, traces, TmfTimestamp.ZERO, indexPageSize);
}
/**
*/
@SuppressWarnings("unchecked")
public TmfExperiment(TmfExperiment<T> other) {
- super(other.getName() + "(clone)", other.fType); //$NON-NLS-1$
+ super(other.getName() + "(copy)", other.fType); //$NON-NLS-1$
fEpoch = other.fEpoch;
fIndexPageSize = other.fIndexPageSize;
TmfExperimentDisposedSignal<T> signal = new TmfExperimentDisposedSignal<T>(this, this);
broadcast(signal);
+ if (fCurrentExperiment == this) {
+ fCurrentExperiment = null;
+ }
if (fTraces != null) {
for (ITmfTrace trace : fTraces) {
}
@Override
- public TmfTimestamp getStartTime() {
+ public ITmfTimestamp getStartTime() {
return fTimeRange.getStartTime();
}
@Override
- public TmfTimestamp getEndTime() {
+ public ITmfTimestamp getEndTime() {
return fTimeRange.getEndTime();
}
// ------------------------------------------------------------------------
public static void setCurrentExperiment(TmfExperiment<?> experiment) {
+ if (fCurrentExperiment != null && fCurrentExperiment != experiment) {
+ fCurrentExperiment.dispose();
+ }
fCurrentExperiment = experiment;
}
return fCurrentExperiment;
}
- public TmfTimestamp getEpoch() {
+ public ITmfTimestamp getEpoch() {
return fEpoch;
}
* Returns the rank of the first event with the requested timestamp. If none, returns the index of the next event
* (if any).
*
- * @param timestamp
- * @return
+ * @param timestamp the event timestamp
+ * @return the corresponding event rank
*/
@Override
- public long getRank(TmfTimestamp timestamp) {
+ public long getRank(ITmfTimestamp timestamp) {
TmfExperimentContext context = seekEvent(timestamp);
return context.getRank();
}
/**
* Returns the timestamp of the event at the requested index. If none, returns null.
*
- * @param index
- * @return
+ * @param index the event index (rank)
+ * @return the corresponding event timestamp
*/
- public TmfTimestamp getTimestamp(int index) {
+ public ITmfTimestamp getTimestamp(int index) {
TmfExperimentContext context = seekEvent(index);
- TmfEvent event = getNextEvent(context);
+ ITmfEvent event = getNextEvent(context);
return (event != null) ? event.getTimestamp() : null;
}
* Update the global time range
*/
protected void updateTimeRange() {
- TmfTimestamp startTime = fTimeRange != TmfTimeRange.Null ? fTimeRange.getStartTime() : TmfTimestamp.BigCrunch;
- TmfTimestamp endTime = fTimeRange != TmfTimeRange.Null ? fTimeRange.getEndTime() : TmfTimestamp.BigBang;
+ ITmfTimestamp startTime = fTimeRange != TmfTimeRange.NULL_RANGE ? fTimeRange.getStartTime() : TmfTimestamp.BIG_CRUNCH;
+ ITmfTimestamp endTime = fTimeRange != TmfTimeRange.NULL_RANGE ? fTimeRange.getEndTime() : TmfTimestamp.BIG_BANG;
for (ITmfTrace<T> trace : fTraces) {
- TmfTimestamp traceStartTime = trace.getStartTime();
+ ITmfTimestamp traceStartTime = trace.getStartTime();
if (traceStartTime.compareTo(startTime, true) < 0)
startTime = traceStartTime;
- TmfTimestamp traceEndTime = trace.getEndTime();
+ ITmfTimestamp traceEndTime = trace.getEndTime();
if (traceEndTime.compareTo(endTime, true) > 0)
endTime = traceEndTime;
}
@Override
public ITmfContext armRequest(ITmfDataRequest<T> request) {
// Tracer.trace("Ctx: Arming request - start");
- TmfTimestamp timestamp = (request instanceof ITmfEventRequest<?>) ? ((ITmfEventRequest<T>) request).getRange().getStartTime()
+ ITmfTimestamp timestamp = (request instanceof ITmfEventRequest<?>) ? ((ITmfEventRequest<T>) request).getRange().getStartTime()
: null;
- if (TmfTimestamp.BigBang.equals(timestamp) || request.getIndex() > 0) {
+ if (TmfTimestamp.BIG_BANG.equals(timestamp) || request.getIndex() > 0) {
timestamp = null; // use request index
}
rank += traceRank;
// Set the trace location and read the corresponding event
- expLocation.getLocation().locations[i] = context.getContexts()[i].getLocation();
+ /* The (TmfContext) cast should be safe since we created 'context'
+ * ourselves higher up. */
+ expLocation.getLocation().locations[i] = ((TmfContext) context.getContexts()[i]).getLocation().clone();
context.getEvents()[i] = fTraces[i].getNextEvent(context.getContexts()[i]);
}
* @see org.eclipse.linuxtools.tmf.trace.ITmfTrace#seekEvent(org.eclipse.linuxtools .tmf.event.TmfTimestamp)
*/
@Override
- public synchronized TmfExperimentContext seekEvent(TmfTimestamp timestamp) {
+ public synchronized TmfExperimentContext seekEvent(ITmfTimestamp timestamp) {
// Tracer.trace("Ctx: seekEvent(TS) - start");
if (timestamp == null) {
- timestamp = TmfTimestamp.BigBang;
+ timestamp = TmfTimestamp.BIG_BANG;
}
// First, find the right checkpoint
context.setRank((long) index * fIndexPageSize);
// And locate the event
- TmfEvent event = parseEvent(context);
+ ITmfEvent event = parseEvent(context);
while (event != null && event.getTimestamp().compareTo(timestamp, false) < 0) {
getNextEvent(context);
event = parseEvent(context);
context.setRank((long) index * fIndexPageSize);
// And locate the event
- TmfEvent event = parseEvent(context);
+ ITmfEvent event = parseEvent(context);
long pos = context.getRank();
while (event != null && pos++ < rank) {
getNextEvent(context);
return null;
}
- /**
- * Scan the next events from all traces and return the next one in chronological order.
- *
- * @param context
- * @return
- */
-
// private void dumpContext(TmfExperimentContext context, boolean isBefore) {
// TmfContext context0 = context.getContexts()[0];
// Tracer.trace(result.toString());
// }
+ /**
+ * Scan the next events from all traces and return the next one in chronological order.
+ *
+ * @param context the trace context
+ * @return the next event
+ */
+ @SuppressWarnings("unchecked")
@Override
- public synchronized TmfEvent getNextEvent(TmfContext context) {
+ public synchronized ITmfEvent getNextEvent(ITmfContext context) {
// Validate the context
if (!(context instanceof TmfExperimentContext)) {
// If an event was consumed previously, get the next one from that trace
int lastTrace = expContext.getLastTrace();
if (lastTrace != TmfExperimentContext.NO_TRACE) {
- TmfContext traceContext = expContext.getContexts()[lastTrace];
+ ITmfContext traceContext = expContext.getContexts()[lastTrace];
expContext.getEvents()[lastTrace] = expContext.getTraces()[lastTrace].getNextEvent(traceContext);
expContext.setLastTrace(TmfExperimentContext.NO_TRACE);
}
// Scan the candidate events and identify the "next" trace to read from
- TmfEvent eventArray[] = expContext.getEvents();
+ ITmfEvent eventArray[] = expContext.getEvents();
if (eventArray == null) {
return null;
}
int trace = TmfExperimentContext.NO_TRACE;
- TmfTimestamp timestamp = TmfTimestamp.BigCrunch;
+ ITmfTimestamp timestamp = TmfTimestamp.BIG_CRUNCH;
if (eventArray.length == 1) {
if (eventArray[0] != null) {
timestamp = eventArray[0].getTimestamp();
}
} else {
for (int i = 0; i < eventArray.length; i++) {
- TmfEvent event = eventArray[i];
+ ITmfEvent event = eventArray[i];
if (event != null && event.getTimestamp() != null) {
- TmfTimestamp otherTS = event.getTimestamp();
+ ITmfTimestamp otherTS = event.getTimestamp();
if (otherTS.compareTo(timestamp, true) < 0) {
trace = i;
timestamp = otherTS;
}
}
// Update the experiment context and set the "next" event
- TmfEvent event = null;
+ ITmfEvent event = null;
if (trace != TmfExperimentContext.NO_TRACE) {
updateIndex(expContext, timestamp);
- TmfContext traceContext = expContext.getContexts()[trace];
+ ITmfContext traceContext = expContext.getContexts()[trace];
TmfExperimentLocation expLocation = (TmfExperimentLocation) expContext.getLocation();
// expLocation.getLocation()[trace] = traceContext.getLocation().clone();
- expLocation.getLocation().locations[trace] = traceContext.getLocation();
+ expLocation.getLocation().locations[trace] = (ITmfLocation<? extends Comparable<?>>) traceContext.getLocation().clone();
// updateIndex(expContext, timestamp);
return event;
}
- public synchronized void updateIndex(ITmfContext context, TmfTimestamp timestamp) {
+ public synchronized void updateIndex(ITmfContext context, ITmfTimestamp timestamp) {
// Build the index as we go along
long rank = context.getRank();
if (context.isValidRank() && (rank % fIndexPageSize) == 0) {
* @see org.eclipse.linuxtools.tmf.trace.ITmfTrace#parseEvent(org.eclipse.linuxtools .tmf.trace.TmfContext)
*/
@Override
- public TmfEvent parseEvent(TmfContext context) {
+ public ITmfEvent parseEvent(ITmfContext context) {
// Validate the context
if (!(context instanceof TmfExperimentContext)) {
// If an event was consumed previously, get the next one from that trace
int lastTrace = expContext.getLastTrace();
if (lastTrace != TmfExperimentContext.NO_TRACE) {
- TmfContext traceContext = expContext.getContexts()[lastTrace];
+ ITmfContext traceContext = expContext.getContexts()[lastTrace];
expContext.getEvents()[lastTrace] = expContext.getTraces()[lastTrace].getNextEvent(traceContext);
expContext.setLastTrace(TmfExperimentContext.NO_TRACE);
fExperimentContext = (TmfExperimentContext) context;
// Scan the candidate events and identify the "next" trace to read from
int trace = TmfExperimentContext.NO_TRACE;
- TmfTimestamp timestamp = TmfTimestamp.BigCrunch;
+ ITmfTimestamp timestamp = TmfTimestamp.BIG_CRUNCH;
for (int i = 0; i < expContext.getTraces().length; i++) {
- TmfEvent event = expContext.getEvents()[i];
+ ITmfEvent event = expContext.getEvents()[i];
if (event != null && event.getTimestamp() != null) {
- TmfTimestamp otherTS = event.getTimestamp();
+ ITmfTimestamp otherTS = event.getTimestamp();
if (otherTS.compareTo(timestamp, true) < 0) {
trace = i;
timestamp = otherTS;
}
}
- TmfEvent event = null;
+ ITmfEvent event = null;
if (trace != TmfExperimentContext.NO_TRACE) {
event = expContext.getEvents()[trace];
}
// Indexing
// ------------------------------------------------------------------------
+ private synchronized void initializeStreamingMonitor() {
+ if (fInitialized) {
+ return;
+ }
+ fInitialized = true;
+
+ if (getStreamingInterval() == 0) {
+ TmfContext context = seekLocation(null);
+ ITmfEvent event = getNext(context);
+ if (event == null) {
+ return;
+ }
+ TmfTimeRange timeRange = new TmfTimeRange(event.getTimestamp().clone(), TmfTimestamp.BIG_CRUNCH);
+ final TmfExperimentRangeUpdatedSignal signal = new TmfExperimentRangeUpdatedSignal(this, this, timeRange);
+
+ // Broadcast in separate thread to prevent deadlock
+ new Thread() {
+ @Override
+ public void run() {
+ broadcast(signal);
+ }
+ }.start();
+ return;
+ }
+
+ final Thread thread = new Thread("Streaming Monitor for experiment " + getName()) { //$NON-NLS-1$
+ ITmfTimestamp safeTimestamp = null;
+ TmfTimeRange timeRange = null;
+
+ @Override
+ public void run() {
+ while (!fExecutor.isShutdown()) {
+ if (!isIndexingBusy()) {
+ ITmfTimestamp startTimestamp = TmfTimestamp.BIG_CRUNCH;
+ ITmfTimestamp endTimestamp = TmfTimestamp.BIG_BANG;
+ for (ITmfTrace<T> trace : fTraces) {
+ if (trace.getStartTime().compareTo(startTimestamp) < 0) {
+ startTimestamp = trace.getStartTime();
+ }
+ if (trace.getStreamingInterval() != 0 && trace.getEndTime().compareTo(endTimestamp) > 0) {
+ endTimestamp = trace.getEndTime();
+ }
+ }
+ if (safeTimestamp != null && safeTimestamp.compareTo(getTimeRange().getEndTime(), false) > 0) {
+ timeRange = new TmfTimeRange(startTimestamp, safeTimestamp);
+ } else {
+ timeRange = null;
+ }
+ safeTimestamp = endTimestamp;
+ if (timeRange != null) {
+ TmfExperimentRangeUpdatedSignal signal =
+ new TmfExperimentRangeUpdatedSignal(TmfExperiment.this, TmfExperiment.this, timeRange);
+ broadcast(signal);
+ }
+ }
+ try {
+ Thread.sleep(getStreamingInterval());
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ };
+ thread.start();
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.linuxtools.tmf.trace.ITmfTrace#getStreamingInterval()
+ */
+ @Override
+ public long getStreamingInterval() {
+ long interval = 0;
+ for (ITmfTrace<T> trace : fTraces) {
+ interval = Math.max(interval, trace.getStreamingInterval());
+ }
+ return interval;
+ }
+
/*
* The experiment holds the globally ordered events of its set of traces. It is expected to provide access to each
* individual event by index i.e. it must be possible to request the Nth event of the experiment.
private static final int DEFAULT_INDEX_PAGE_SIZE = 5000;
protected int fIndexPageSize;
protected boolean fIndexing = false;
- protected TmfTimeRange fIndexingPendingRange = TmfTimeRange.Null;
+ protected TmfTimeRange fIndexingPendingRange = TmfTimeRange.NULL_RANGE;
+
+ private Integer fEndSynchReference;
// private static BufferedWriter fEventLog = null;
// private static BufferedWriter openLogFile(String filename) {
}
protected void indexExperiment(boolean waitForCompletion) {
- indexExperiment(waitForCompletion, 0, TmfTimeRange.Eternity);
+ indexExperiment(waitForCompletion, 0, TmfTimeRange.ETERNITY);
}
@SuppressWarnings("unchecked")
// fEventLog = openLogFile("TraceEvent.log");
// System.out.println(System.currentTimeMillis() + ": Experiment indexing started");
- ITmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, timeRange, index, TmfDataRequest.ALL_DATA,
+ ITmfEventRequest<ITmfEvent> request = new TmfEventRequest<ITmfEvent>(ITmfEvent.class, timeRange, index, TmfDataRequest.ALL_DATA,
fIndexPageSize, ITmfDataRequest.ExecutionType.BACKGROUND) { // PATA FOREGROUND
// long indexingStart = System.nanoTime();
- TmfTimestamp startTime = (fTimeRange == TmfTimeRange.Null) ? null : fTimeRange.getStartTime();
- TmfTimestamp lastTime = (fTimeRange == TmfTimeRange.Null) ? null : fTimeRange.getEndTime();
+ ITmfTimestamp startTime = (fTimeRange == TmfTimeRange.NULL_RANGE) ? null : fTimeRange.getStartTime();
+ ITmfTimestamp lastTime = (fTimeRange == TmfTimeRange.NULL_RANGE) ? null : fTimeRange.getEndTime();
long initialNbEvents = fNbEvents;
@Override
}
@Override
- public void handleData(TmfEvent event) {
+ public void handleData(ITmfEvent event) {
super.handleData(event);
if (event != null) {
- TmfTimestamp ts = event.getTimestamp();
+ ITmfTimestamp ts = event.getTimestamp();
if (startTime == null)
- startTime = new TmfTimestamp(ts);
- lastTime = new TmfTimestamp(ts);
+ startTime = ts.clone();
+ lastTime = ts.clone();
if ((getNbRead() % fIndexPageSize) == 1 && getNbRead() != 1) {
updateExperiment();
}
public void handleSuccess() {
// long indexingEnd = System.nanoTime();
- if (getRange() != TmfTimeRange.Eternity) {
+ // if the end time is a real value then it is the streaming safe time stamp
+ // set the last time to the safe time stamp to prevent unnecessary indexing requests
+ if (getRange().getEndTime() != TmfTimestamp.BIG_CRUNCH) {
lastTime = getRange().getEndTime();
}
updateExperiment();
super.handleCompleted();
synchronized (fCheckpoints) {
fIndexing = false;
- if (fIndexingPendingRange != TmfTimeRange.Null) {
+ if (fIndexingPendingRange != TmfTimeRange.NULL_RANGE) {
indexExperiment(false, (int) fNbEvents, fIndexingPendingRange);
- fIndexingPendingRange = TmfTimeRange.Null;
+ fIndexingPendingRange = TmfTimeRange.NULL_RANGE;
}
}
}
private void updateExperiment() {
int nbRead = getNbRead();
if (startTime != null) {
- fTimeRange = new TmfTimeRange(startTime, new TmfTimestamp(lastTime));
+ fTimeRange = new TmfTimeRange(startTime, lastTime.clone());
}
if (nbRead != 0) {
// updateTimeRange();
protected void notifyListeners() {
broadcast(new TmfExperimentUpdatedSignal(this, this)); // , null));
- broadcast(new TmfExperimentRangeUpdatedSignal(this, this, fTimeRange)); // , null));
+ //broadcast(new TmfExperimentRangeUpdatedSignal(this, this, fTimeRange)); // , null));
}
// ------------------------------------------------------------------------
TmfExperiment<?> experiment = signal.getExperiment();
if (experiment == this) {
setCurrentExperiment(experiment);
- indexExperiment(false);
+ fEndSynchReference = Integer.valueOf(signal.getReference());
}
}
+ @TmfSignalHandler
+ public void endSync(TmfEndSynchSignal signal) {
+ if (fEndSynchReference != null && fEndSynchReference.intValue() == signal.getReference()) {
+ fEndSynchReference = null;
+ initializeStreamingMonitor();
+ }
+
+ }
+
@TmfSignalHandler
public void experimentUpdated(TmfExperimentUpdatedSignal signal) {
}
+ @TmfSignalHandler
+ public void experimentRangeUpdated(TmfExperimentRangeUpdatedSignal signal) {
+ if (signal.getExperiment() == this) {
+ indexExperiment(false, (int) fNbEvents, signal.getRange());
+ }
+ }
+
@TmfSignalHandler
public void traceUpdated(TmfTraceUpdatedSignal signal) {
for (ITmfTrace<T> trace : fTraces) {
if (trace == signal.getTrace()) {
synchronized (fCheckpoints) {
if (fIndexing) {
- if (fIndexingPendingRange == TmfTimeRange.Null) {
+ if (fIndexingPendingRange == TmfTimeRange.NULL_RANGE) {
fIndexingPendingRange = signal.getRange();
} else {
- TmfTimestamp startTime = fIndexingPendingRange.getStartTime();
- TmfTimestamp endTime = fIndexingPendingRange.getEndTime();
+ ITmfTimestamp startTime = fIndexingPendingRange.getStartTime();
+ ITmfTimestamp endTime = fIndexingPendingRange.getEndTime();
if (signal.getRange().getStartTime().compareTo(startTime) < 0) {
startTime = signal.getRange().getStartTime();
}
return null;
}
+ /**
+ * Set the file to be used for bookmarks on this experiment
+ * @param file the bookmarks file
+ */
+ public void setBookmarksFile(IFile file) {
+ fBookmarksFile = file;
+ }
+
+ /**
+ * Get the file used for bookmarks on this experiment
+ * @return the bookmarks file or null if none is set
+ */
+ public IFile getBookmarksFile() {
+ return fBookmarksFile;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#setResource(org.eclipse.core.resources.IResource)
+ */
+ @Override
+ public void setResource(IResource resource) {
+ fResource = resource;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getResource()
+ */
+ @Override
+ public IResource getResource() {
+ return fResource;
+ }
}
projects / deliverable / tracecompass.git / blobdiff