import org.eclipse.core.runtime.Path;
import org.eclipse.linuxtools.lttng.core.tests.LTTngCoreTestPlugin;
import org.eclipse.linuxtools.lttng.core.trace.LTTngTextTrace;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
import org.eclipse.linuxtools.tmf.core.trace.TmfLocation;
}
*/
public void testGetNextEvent() {
- TmfEvent tmpEvent = null;
+ ITmfEvent tmpEvent = null;
LTTngTextTrace testStream1 = prepareStreamToTest();
TmfContext tmpContext = new TmfContext(null, 0);
}
public void testParseEvent() {
- TmfEvent tmpEvent = null;
+ ITmfEvent tmpEvent = null;
LTTngTextTrace testStream1 = prepareStreamToTest();
TmfContext tmpContext = new TmfContext(null, 0);
}
public void testSeekEventTimestamp() {
- TmfEvent tmpEvent = null;
+ ITmfEvent tmpEvent = null;
TmfContext tmpContext = new TmfContext(null, 0);
LTTngTextTrace testStream1 = prepareStreamToTest();
}
public void testSeekEventIndex() {
- TmfEvent tmpEvent = null;
+ ITmfEvent tmpEvent = null;
TmfContext tmpContext = new TmfContext(null, 0);
LTTngTextTrace testStream1 = prepareStreamToTest();
}
public void testSeekLocation() {
- TmfEvent tmpEvent = null;
+ ITmfEvent tmpEvent = null;
TmfContext tmpContext = new TmfContext(null, 0);
LTTngTextTrace testStream1 = prepareStreamToTest();
@SuppressWarnings("unchecked")
public void testGetter() {
- TmfEvent tmpEvent = null;
+ ITmfEvent tmpEvent = null;
LTTngTextTrace testStream1 = prepareStreamToTest();
TmfContext tmpContext = new TmfContext(null, 0);
import org.eclipse.linuxtools.lttng.core.event.LttngTimestamp;
import org.eclipse.linuxtools.lttng.core.tracecontrol.utility.LiveTraceManager;
import org.eclipse.linuxtools.lttng.jni.JniTrace;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.experiment.TmfExperiment;
* Temporary class to resolve a basic incompatibility between TMF and LTTng.
* <p>
*/
-public class LTTngExperiment<T extends TmfEvent> extends TmfExperiment<T> {
+public class LTTngExperiment<T extends ITmfEvent> extends TmfExperiment<T> {
private static final int DEFAULT_INDEX_PAGE_SIZE = 50000;
// ------------------------------------------------------------------------
@Override
- public synchronized TmfEvent getNextEvent(TmfContext context) {
+ public synchronized ITmfEvent getNextEvent(TmfContext context) {
// Validate the context
if (!(context instanceof TmfExperimentContext)) {
}
// 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;
}
}
} else {
for (int i = 0; i < eventArray.length; i++) {
- TmfEvent event = eventArray[i];
+ ITmfEvent event = eventArray[i];
if (event != null && event.getTimestamp() != null) {
ITmfTimestamp otherTS = event.getTimestamp();
if (otherTS.compareTo(timestamp, true) < 0) {
}
// Update the experiment context and set the "next" event
- TmfEvent event = null;
+ ITmfEvent event = null;
if (trace != TmfExperimentContext.NO_TRACE) {
// updateIndex(expContext, timestamp);
import java.io.IOException;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.lttng.core.event.LttngEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.parser.ITmfEventParser;
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
* <p>
* TODO: Implement me. Please.
*/
-public class LTTngEventParserStub implements ITmfEventParser {
+public class LTTngEventParserStub implements ITmfEventParser<LttngEvent> {
- @Override
- public TmfEvent parseNextEvent(ITmfTrace<?> stream, TmfContext context)
- throws IOException {
- // TODO Auto-generated method stub
- return null;
- }
+ /* (non-Javadoc)
+ * @see org.eclipse.linuxtools.tmf.core.parser.ITmfEventParser#parseNextEvent(org.eclipse.linuxtools.tmf.core.trace.ITmfTrace, org.eclipse.linuxtools.tmf.core.trace.TmfContext)
+ */
+ @Override
+ public ITmfEvent parseNextEvent(ITmfTrace<LttngEvent> stream, TmfContext context)
+ throws IOException {
+ // TODO Auto-generated method stub
+ return null;
+ }
// // ========================================================================
// // Attributes
import java.io.RandomAccessFile;
import org.eclipse.linuxtools.lttng.core.event.LttngEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.parser.ITmfEventParser;
import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation;
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
private final RandomAccessFile fTrace;
// The associated event parser
- private final ITmfEventParser fParser;
+ private final ITmfEventParser<LttngEvent> fParser;
// ========================================================================
// Constructors
* @see org.eclipse.linuxtools.tmf.trace.ITmfTrace#parseEvent()
*/
@Override
- public TmfEvent parseEvent(TmfContext context) {
+ public ITmfEvent parseEvent(TmfContext context) {
try {
// paserNextEvent updates the context
- TmfEvent event = fParser.parseNextEvent(this, context);
+ LttngEvent event = (LttngEvent) fParser.parseNextEvent(this, context);
// if (event != null) {
// context.setTimestamp(event.getTimestamp());
// }
import org.eclipse.linuxtools.lttng.ui.views.statistics.model.KernelStatisticsData;
import org.eclipse.linuxtools.lttng.ui.views.statistics.model.StatisticsTreeNode;
import org.eclipse.linuxtools.lttng.ui.views.statistics.model.StatisticsTreeRootFactory;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.experiment.TmfExperiment;
import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest.ExecutionType;
* @param signal
*/
@TmfSignalHandler
- public void experimentSelected(TmfExperimentSelectedSignal<? extends TmfEvent> signal) {
+ public void experimentSelected(TmfExperimentSelectedSignal<? extends ITmfEvent> signal) {
if (signal != null) {
TmfExperiment<?> experiment = signal.getExperiment();
String experimentName = experiment.getName();
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
for (int i = 0; i < checkpoints.size(); i++) {
TmfCheckpoint checkpoint = checkpoints.get(i);
TmfExperimentContext context = fExperiment.seekLocation(checkpoint.getLocation());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event rank", i * pageSize, context.getRank());
assertTrue("Timestamp", (checkpoint.getTimestamp().compareTo(event.getTimestamp(), false) == 0));
}
TmfContext context = fExperiment.seekLocation(null);
assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
TmfContext context = fExperiment.seekLocation(tmpContext.getLocation());
assertEquals("Event rank", 9, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
assertEquals("Event rank", 9, context.getRank());
TmfContext context = fExperiment.seekLocation(tmpContext.getLocation());
assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
TmfContext context = fExperiment.seekEvent(new TmfTimestamp(1, SCALE, 0));
assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
TmfContext context = fExperiment.seekEvent(new TmfTimestamp(2, SCALE, 0));
assertEquals("Event rank", 1, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
assertEquals("Event rank", 1, context.getRank());
TmfContext context = fExperiment.seekEvent(new TmfTimestamp(-1, SCALE, 0));
assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
TmfContext context = fExperiment.seekEvent(0);
assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
TmfContext context = fExperiment.seekEvent(9);
assertEquals("Event rank", 9, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
assertEquals("Event rank", 9, context.getRank());
TmfContext context = fExperiment.seekEvent(-1);
assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
TmfContext context = fExperiment.seekEvent(new TmfTimestamp(0, SCALE, 0));
// Read NB_EVENTS
- TmfEvent event = null;;
+ ITmfEvent event = null;;
for (int i = 0; i < NB_READS; i++) {
event = fExperiment.getNextEvent(context);
assertEquals("Event timestamp", i + 1, event.getTimestamp().getValue());
// On lower bound, returns the first event (ts = 0)
TmfContext context = fExperiment.seekEvent(new TmfTimestamp(0, SCALE, 0));
- TmfEvent event = fExperiment.getNextEvent(context);
+ ITmfEvent event = fExperiment.getNextEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
for (int i = 2; i < 20; i++) {
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
for (int i = 0; i < checkpoints.size(); i++) {
TmfCheckpoint checkpoint = checkpoints.get(i);
TmfExperimentContext context = fExperiment.seekLocation(checkpoint.getLocation());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event rank", context.getRank(), i * pageSize);
assertTrue("Timestamp", (checkpoint.getTimestamp().compareTo(event.getTimestamp(), false) == 0));
}
TmfContext context = fExperiment.seekLocation(null);
assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
TmfContext context = fExperiment.seekLocation(tmpContext.getLocation());
assertEquals("Event rank", 9, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
assertEquals("Event rank", 9, context.getRank());
TmfContext context = fExperiment.seekLocation(tmpContext.getLocation());
assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
TmfContext context = fExperiment.seekEvent(new TmfTimestamp(1, SCALE, 0));
assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
TmfContext context = fExperiment.seekEvent(new TmfTimestamp(2, SCALE, 0));
assertEquals("Event rank", 1, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
assertEquals("Event rank", 1, context.getRank());
TmfContext context = fExperiment.seekEvent(new TmfTimestamp(-1, SCALE, 0));
assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
TmfContext context = fExperiment.seekEvent(0);
assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
TmfContext context = fExperiment.seekEvent(9);
assertEquals("Event rank", 9, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
assertEquals("Event rank", 9, context.getRank());
TmfContext context = fExperiment.seekEvent(-1);
assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
TmfContext context = fExperiment.seekEvent(new TmfTimestamp(0, SCALE, 0));
// Read NB_EVENTS
- TmfEvent event = null;;
+ ITmfEvent event = null;;
for (int i = 0; i < NB_READS; i++) {
event = fExperiment.getNextEvent(context);
assertEquals("Event timestamp", i + 1, event.getTimestamp().getValue());
// On lower bound, returns the first event (ts = 0)
TmfContext context = fExperiment.seekEvent(new TmfTimestamp(0, SCALE, 0));
- TmfEvent event = fExperiment.getNextEvent(context);
+ ITmfEvent event = fExperiment.getNextEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
for (int i = 2; i < 20; i++) {
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
for (int i = 0; i < checkpoints.size(); i++) {
TmfCheckpoint checkpoint = checkpoints.get(i);
TmfExperimentContext context = fExperiment.seekLocation(checkpoint.getLocation());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
// assertEquals("Event rank", context.getRank(), i * pageSize);
assertTrue("Timestamp", (checkpoint.getTimestamp().compareTo(event.getTimestamp(), false) == 0));
}
// On lower bound, returns the first event (ts = 0)
TmfContext context = fExperiment.seekEvent(new TmfTimestamp(0, SCALE, 0));
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
event = fExperiment.parseEvent(context);
// On lower bound, returns the first event (ts = 0)
TmfContext context = fExperiment.seekEvent(new TmfTimestamp(0, SCALE, 0));
- TmfEvent event = fExperiment.getNextEvent(context);
+ ITmfEvent event = fExperiment.getNextEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
for (int i = 2; i < 20; i++) {
// Position trace at event rank 0
TmfContext context = fExperiment.seekLocation(null);
// assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
// assertEquals("Event rank", 0, context.getRank());
event = fExperiment.getNextEvent(context);
TmfContext tmpContext = fExperiment.seekEvent(new TmfTimestamp(10, SCALE, 0));
TmfContext context = fExperiment.seekLocation(tmpContext.getLocation().clone());
// assertEquals("Event rank", 9, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
// assertEquals("Event rank", 9, context.getRank());
event = fExperiment.getNextEvent(context);
TmfContext tmpContext = fExperiment.seekLocation(null);
TmfContext context = fExperiment.seekLocation(tmpContext.getLocation().clone());
// assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
// assertEquals("Event rank", 0, context.getRank());
event = fExperiment.getNextEvent(context);
// Position trace at event rank 0
TmfContext context = fExperiment.seekEvent(new TmfTimestamp(1, SCALE, 0));
assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
event = fExperiment.getNextEvent(context);
// Position trace at event rank 1
TmfContext context = fExperiment.seekEvent(new TmfTimestamp(2, SCALE, 0));
assertEquals("Event rank", 1, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
assertEquals("Event rank", 1, context.getRank());
event = fExperiment.getNextEvent(context);
// Position trace at beginning
TmfContext context = fExperiment.seekEvent(new TmfTimestamp(-1, SCALE, 0));
assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
event = fExperiment.getNextEvent(context);
// On lower bound, returns the first event (ts = 1)
TmfContext context = fExperiment.seekEvent(0);
assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
event = fExperiment.getNextEvent(context);
// Position trace at event rank 9
TmfContext context = fExperiment.seekEvent(9);
assertEquals("Event rank", 9, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
assertEquals("Event rank", 9, context.getRank());
event = fExperiment.getNextEvent(context);
// Position trace at beginning
TmfContext context = fExperiment.seekEvent(-1);
assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fExperiment.parseEvent(context);
+ ITmfEvent event = fExperiment.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
event = fExperiment.getNextEvent(context);
import org.eclipse.core.runtime.Path;
import org.eclipse.linuxtools.tmf.core.component.ITmfDataProvider;
import org.eclipse.linuxtools.tmf.core.component.TmfProviderManager;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
for (int i = 0; i < checkpoints.size(); i++) {
TmfCheckpoint checkpoint = checkpoints.get(i);
TmfContext context = new TmfContext(checkpoint.getLocation(), i * pageSize);
- TmfEvent event = fTrace.parseEvent(context);
+ ITmfEvent event = fTrace.parseEvent(context);
assertTrue(context.getRank() == i * pageSize);
assertTrue((checkpoint.getTimestamp().compareTo(event.getTimestamp(), false) == 0));
}
TmfContext context = fTrace.seekEvent(new TmfTimestamp(0, SCALE, 0));
TmfContext svContext = new TmfContext(context);
- TmfEvent event = fTrace.parseEvent(context);
+ ITmfEvent event = fTrace.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
assertTrue("parseEvent", context.equals(svContext));
TmfContext context = fTrace.seekEvent(new TmfTimestamp(0, SCALE, 0));
// Read NB_EVENTS
- TmfEvent event;
+ ITmfEvent event;
for (int i = 0; i < NB_READS; i++) {
event = fTrace.getNextEvent(context);
assertEquals("Event timestamp", i + 1, event.getTimestamp().getValue());
// Position trace at event rank 0
TmfContext context = fTrace.seekLocation(null);
- TmfEvent event = fTrace.parseEvent(context);
+ ITmfEvent event = fTrace.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
TmfContext context = fTrace.seekLocation(tmpContext.getLocation());
assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
- TmfEvent event = fTrace.parseEvent(context);
+ ITmfEvent event = fTrace.parseEvent(context);
assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
TmfContext context = fTrace.seekLocation(tmpContext.getLocation());
assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
- TmfEvent event = fTrace.parseEvent(context);
+ ITmfEvent event = fTrace.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
TmfContext context = fTrace.seekEvent(new TmfTimestamp(1, SCALE, 0));
assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fTrace.parseEvent(context);
+ ITmfEvent event = fTrace.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
TmfContext context = fTrace.seekEvent(new TmfTimestamp(2, SCALE, 0));
assertEquals("Event rank", 1, context.getRank());
- TmfEvent event = fTrace.parseEvent(context);
+ ITmfEvent event = fTrace.parseEvent(context);
assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
assertEquals("Event rank", 1, context.getRank());
TmfContext context = fTrace.seekEvent(new TmfTimestamp(-1, SCALE, 0));
assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fTrace.parseEvent(context);
+ ITmfEvent event = fTrace.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
TmfContext context = fTrace.seekEvent(0);
assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fTrace.parseEvent(context);
+ ITmfEvent event = fTrace.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
TmfContext context = fTrace.seekEvent(9);
assertEquals("Event rank", 9, context.getRank());
- TmfEvent event = fTrace.parseEvent(context);
+ ITmfEvent event = fTrace.parseEvent(context);
assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
assertEquals("Event rank", 9, context.getRank());
TmfContext context = fTrace.seekEvent(-1);
assertEquals("Event rank", 0, context.getRank());
- TmfEvent event = fTrace.parseEvent(context);
+ ITmfEvent event = fTrace.parseEvent(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertEquals("Event rank", 0, context.getRank());
import java.io.RandomAccessFile;
import java.util.Vector;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
* TODO: Implement me. Please.
*/
@SuppressWarnings("nls")
-public class TmfEventParserStub implements ITmfEventParser {
+public class TmfEventParserStub implements ITmfEventParser<TmfEvent> {
// ------------------------------------------------------------------------
// Attributes
static final String typePrefix = "Type-";
@Override
@SuppressWarnings("unchecked")
- public TmfEvent parseNextEvent(ITmfTrace<?> eventStream, TmfContext context) throws IOException {
+ public ITmfEvent parseNextEvent(ITmfTrace<TmfEvent> eventStream, TmfContext context) throws IOException {
if (! (eventStream instanceof TmfTraceStub)) {
return null;
content.append("]");
TmfEventField root = new TmfEventField(ITmfEventField.ROOT_ID, content.toString());
- TmfEvent event = new TmfEvent(eventStream,
+ ITmfEvent event = new TmfEvent(eventStream,
new TmfTimestamp(ts, -3, 0), // millisecs
source, fTypes[typeIndex], root, reference.toString());
return event;
import java.io.RandomAccessFile;
import java.util.concurrent.locks.ReentrantLock;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
private RandomAccessFile fTrace;
// The associated event parser
- private ITmfEventParser fParser;
+ private ITmfEventParser<TmfEvent> fParser;
// The synchronization lock
private ReentrantLock fLock = new ReentrantLock();
* @param parser
* @throws FileNotFoundException
*/
- public TmfTraceStub(String filename, int cacheSize, boolean waitForCompletion, ITmfEventParser parser) throws FileNotFoundException {
+ public TmfTraceStub(String filename, int cacheSize, boolean waitForCompletion, ITmfEventParser<TmfEvent> parser) throws FileNotFoundException {
super(filename, TmfEvent.class, filename, cacheSize, false);
fTrace = new RandomAccessFile(filename, "r");
fParser = parser;
}
@Override
- public TmfEvent parseEvent(TmfContext context) {
+ public ITmfEvent parseEvent(TmfContext context) {
fLock.lock();
try {
// parseNextEvent will update the context
if (fTrace != null) {
- TmfEvent event = fParser.parseNextEvent(this, context.clone());
+ ITmfEvent event = fParser.parseNextEvent(this, context.clone());
return event;
}
}
import org.eclipse.core.runtime.Platform;\r
import org.eclipse.linuxtools.tmf.core.component.ITmfComponent;\r
import org.eclipse.linuxtools.tmf.core.component.ITmfDataProvider;\r
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;\r
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;\r
import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest;\r
import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest;\r
import org.eclipse.linuxtools.tmf.core.signal.TmfSignal;\r
trace(message);\r
}\r
\r
- public static void traceEvent(ITmfDataProvider<?> provider, ITmfDataRequest<?> request, TmfEvent data) {\r
+ public static void traceEvent(ITmfDataProvider<?> provider, ITmfDataRequest<?> request, ITmfEvent data) {\r
String message = ("[EVT] Provider=" + provider.toString() + ", Req=" + request.getRequestId() + ", Event=" + data\r
.toString());\r
trace(message);\r
package org.eclipse.linuxtools.tmf.core.component;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest;
/**
* <p>
* TODO: Implement me. Please.
*/
-public interface ITmfDataProvider<T extends TmfEvent> {
+public interface ITmfDataProvider<T extends ITmfEvent> {
/**
* Queues the request for processing.
import java.util.concurrent.SynchronousQueue;
import org.eclipse.linuxtools.tmf.core.Tracer;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest;
import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest.ExecutionType;
import org.eclipse.linuxtools.tmf.core.request.TmfCoalescedDataRequest;
* <p>
* TODO: Add support for providing multiple data types.
*/
-public abstract class TmfDataProvider<T extends TmfEvent> extends TmfComponent implements ITmfDataProvider<T> {
+public abstract class TmfDataProvider<T extends ITmfEvent> extends TmfComponent implements ITmfDataProvider<T> {
// ------------------------------------------------------------------------
// Constants
package org.eclipse.linuxtools.tmf.core.component;
import org.eclipse.linuxtools.tmf.core.Tracer;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest;
import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest.ExecutionType;
import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest;
* <b><u>TmfEventProvider</u></b>
* <p>
*/
-public abstract class TmfEventProvider<T extends TmfEvent> extends TmfDataProvider<T> {
+public abstract class TmfEventProvider<T extends ITmfEvent> extends TmfDataProvider<T> {
// ------------------------------------------------------------------------
// Constructors
import java.util.List;
import java.util.Map;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
/**
* <b><u>TmfProviderManager.java</u></b>
// Keeps track of the providers for each event type
// ------------------------------------------------------------------------
- private static Map<Class<? extends TmfEvent>, List<TmfDataProvider<? extends TmfEvent>>> fProviders =
- new HashMap<Class<? extends TmfEvent>, List<TmfDataProvider<? extends TmfEvent>>>();
+ private static Map<Class<? extends ITmfEvent>, List<TmfDataProvider<? extends ITmfEvent>>> fProviders =
+ new HashMap<Class<? extends ITmfEvent>, List<TmfDataProvider<? extends ITmfEvent>>>();
/**
* Registers [provider] as a provider of [eventType]
* @param eventType
* @param provider
*/
- public static <T extends TmfEvent> void register(Class<T> eventType, TmfDataProvider<? extends TmfEvent> provider) {
+ public static <T extends ITmfEvent> void register(Class<T> eventType, TmfDataProvider<? extends ITmfEvent> provider) {
if (fProviders.get(eventType) == null)
- fProviders.put(eventType, new ArrayList<TmfDataProvider<? extends TmfEvent>>());
+ fProviders.put(eventType, new ArrayList<TmfDataProvider<? extends ITmfEvent>>());
fProviders.get(eventType).add(provider);
}
* @param dataClass
* @param provider
*/
- public static <T extends TmfEvent> void deregister(Class<T> dataClass, TmfDataProvider<? extends TmfEvent> provider) {
- List<TmfDataProvider<? extends TmfEvent>> list = fProviders.get(dataClass);
+ public static <T extends ITmfEvent> void deregister(Class<T> dataClass, TmfDataProvider<? extends ITmfEvent> provider) {
+ List<TmfDataProvider<? extends ITmfEvent>> list = fProviders.get(dataClass);
if (list != null) {
list.remove(provider);
if (list.size() == 0)
* @return
*/
@SuppressWarnings("unchecked")
- public static TmfDataProvider<? extends TmfEvent>[] getProviders(Class<? extends TmfEvent> dataClass) {
- List<TmfDataProvider<? extends TmfEvent>> list = fProviders.get(dataClass);
+ public static TmfDataProvider<? extends ITmfEvent>[] getProviders(Class<? extends ITmfEvent> dataClass) {
+ List<TmfDataProvider<? extends ITmfEvent>> list = fProviders.get(dataClass);
if (list == null)
- list = new ArrayList<TmfDataProvider<? extends TmfEvent>>();
- TmfDataProvider<? extends TmfEvent>[] result = new TmfDataProvider[list.size()];
+ list = new ArrayList<TmfDataProvider<? extends ITmfEvent>>();
+ TmfDataProvider<? extends ITmfEvent>[] result = new TmfDataProvider[list.size()];
return list.toArray(result);
}
* @return
*/
@SuppressWarnings("unchecked")
- public static TmfDataProvider<? extends TmfEvent>[] getProviders(Class<? extends TmfEvent> dataClass, Class<? extends TmfDataProvider<? extends TmfEvent>> providerClass) {
+ public static TmfDataProvider<? extends ITmfEvent>[] getProviders(Class<? extends ITmfEvent> dataClass, Class<? extends TmfDataProvider<? extends ITmfEvent>> providerClass) {
if (providerClass == null) {
return getProviders(dataClass);
}
- TmfDataProvider<? extends TmfEvent>[] list = getProviders(dataClass);
- List<TmfDataProvider<? extends TmfEvent>> result = new ArrayList<TmfDataProvider<? extends TmfEvent>>();
+ TmfDataProvider<? extends ITmfEvent>[] list = getProviders(dataClass);
+ List<TmfDataProvider<? extends ITmfEvent>> result = new ArrayList<TmfDataProvider<? extends ITmfEvent>>();
if (list != null) {
- for (TmfDataProvider<? extends TmfEvent> provider : list) {
+ for (TmfDataProvider<? extends ITmfEvent> provider : list) {
if (provider.getClass() == providerClass) {
result.add(provider);
}
}
}
- TmfDataProvider<? extends TmfEvent>[] array = new TmfDataProvider[result.size()];
+ TmfDataProvider<? extends ITmfEvent>[] array = new TmfDataProvider[result.size()];
return result.toArray(array);
}
/**
* The trace containing the event
*/
- protected ITmfTrace<? extends TmfEvent> fTrace;
+ protected ITmfTrace<? extends ITmfEvent> fTrace;
/**
* The event rank within the trace
* @param type the event content (payload)
* @param reference the event reference
*/
- public TmfEvent(ITmfTrace<? extends TmfEvent> trace, long rank, ITmfTimestamp timestamp, String source,
+ public TmfEvent(ITmfTrace<? extends ITmfEvent> trace, long rank, ITmfTimestamp timestamp, String source,
ITmfEventType type, ITmfEventField content, String reference)
{
fTrace = trace;
/**
* Constructor - no rank
*/
- public TmfEvent(ITmfTrace<? extends TmfEvent> trace, ITmfTimestamp timestamp, String source,
+ public TmfEvent(ITmfTrace<? extends ITmfEvent> trace, ITmfTimestamp timestamp, String source,
ITmfEventType type, ITmfEventField content, String reference)
{
this(trace, -1, timestamp, source, type, content, reference);
/**
* Constructor - no rank, no content
*/
- public TmfEvent(ITmfTrace<? extends TmfEvent> trace, ITmfTimestamp timestamp, String source,
+ public TmfEvent(ITmfTrace<? extends ITmfEvent> trace, ITmfTimestamp timestamp, String source,
ITmfEventType type, String reference)
{
this(trace, -1, timestamp, source, type, null, reference);
*
* @param event the original event
*/
- public TmfEvent(TmfEvent event) {
+ public TmfEvent(ITmfEvent event) {
if (event == null)
throw new IllegalArgumentException();
- fTrace = event.fTrace;
- fRank = event.fRank;
- fTimestamp = event.fTimestamp;
- fSource = event.fSource;
- fType = event.fType;
- fContent = event.fContent;
- fReference = event.fReference;
+ fTrace = event.getTrace();
+ fRank = event.getRank();
+ fTimestamp = event.getTimestamp();
+ fSource = event.getSource();
+ fType = event.getType();
+ fContent = event.getContent();
+ fReference = event.getReference();
}
// ------------------------------------------------------------------------
* @see org.eclipse.linuxtools.tmf.core.event.ITmfEvent#getTrace()
*/
@Override
- public ITmfTrace<? extends TmfEvent> getTrace() {
+ public ITmfTrace<? extends ITmfEvent> getTrace() {
return fTrace;
}
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.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest;
* 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
*/
public ITmfTimestamp getTimestamp(int index) {
TmfExperimentContext context = seekEvent(index);
- TmfEvent event = getNextEvent(context);
+ ITmfEvent event = getNextEvent(context);
return (event != null) ? event.getTimestamp() : null;
}
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);
// }
@Override
- public synchronized TmfEvent getNextEvent(TmfContext context) {
+ public synchronized ITmfEvent getNextEvent(TmfContext context) {
// Validate the context
if (!(context instanceof TmfExperimentContext)) {
}
// 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;
}
}
} else {
for (int i = 0; i < eventArray.length; i++) {
- TmfEvent event = eventArray[i];
+ ITmfEvent event = eventArray[i];
if (event != null && event.getTimestamp() != null) {
ITmfTimestamp otherTS = event.getTimestamp();
if (otherTS.compareTo(timestamp, true) < 0) {
}
}
// Update the experiment context and set the "next" event
- TmfEvent event = null;
+ ITmfEvent event = null;
if (trace != TmfExperimentContext.NO_TRACE) {
updateIndex(expContext, timestamp);
* @see org.eclipse.linuxtools.tmf.trace.ITmfTrace#parseEvent(org.eclipse.linuxtools .tmf.trace.TmfContext)
*/
@Override
- public TmfEvent parseEvent(TmfContext context) {
+ public ITmfEvent parseEvent(TmfContext context) {
// Validate the context
if (!(context instanceof TmfExperimentContext)) {
int trace = TmfExperimentContext.NO_TRACE;
ITmfTimestamp timestamp = TmfTimestamp.BigCrunch;
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) {
ITmfTimestamp otherTS = event.getTimestamp();
if (otherTS.compareTo(timestamp, true) < 0) {
}
}
- TmfEvent event = null;
+ ITmfEvent event = null;
if (trace != TmfExperimentContext.NO_TRACE) {
event = expContext.getEvents()[trace];
}
if (getStreamingInterval() == 0) {
TmfContext context = seekLocation(null);
- TmfEvent event = getNext(context);
+ ITmfEvent event = getNext(context);
if (event == null) {
return;
}
// 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();
}
@Override
- public void handleData(TmfEvent event) {
+ public void handleData(ITmfEvent event) {
super.handleData(event);
if (event != null) {
ITmfTimestamp ts = event.getTimestamp();
package org.eclipse.linuxtools.tmf.core.experiment;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation;
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
private ITmfTrace<?>[] fTraces = new ITmfTrace[0];
private TmfContext[] fContexts;
- private TmfEvent[] fEvents;
+ private ITmfEvent[] fEvents;
private int lastTraceRead;
// ------------------------------------------------------------------------
super();
fTraces = traces;
fContexts = contexts;
- fEvents = new TmfEvent[fTraces.length];
+ fEvents = new ITmfEvent[fTraces.length];
ITmfLocation<?>[] locations = new ITmfLocation[fTraces.length];
long[] ranks = new long[fTraces.length];
return fContexts;
}
- public TmfEvent[] getEvents() {
+ public ITmfEvent[] getEvents() {
return fEvents;
}
import java.io.IOException;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
* <p>
* TODO: Implement me. Please.
*/
-public interface ITmfEventParser {
+public interface ITmfEventParser<T extends ITmfEvent> {
/**
* @return
* @throws IOException
*/
- public TmfEvent parseNextEvent(ITmfTrace<?> stream, TmfContext context) throws IOException;
+ public ITmfEvent parseNextEvent(ITmfTrace<T> stream, TmfContext context) throws IOException;
}
package org.eclipse.linuxtools.tmf.core.request;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
/**
* <b><u>ITmfDataRequest</u></b>
* <p>
* TODO: Implement me. Please.
*/
-public interface ITmfDataRequest<T extends TmfEvent> {
+public interface ITmfDataRequest<T extends ITmfEvent> {
// ------------------------------------------------------------------------
// Constants
package org.eclipse.linuxtools.tmf.core.request;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
/**
* <p>
* TODO: Implement me. Please.
*/
-public interface ITmfEventRequest<T extends TmfEvent> extends ITmfDataRequest<T> {
+public interface ITmfEventRequest<T extends ITmfEvent> extends ITmfDataRequest<T> {
/**
* @return the requested time range
import java.util.Vector;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
/**
* <b><u>TmfCoalescedDataRequest</u></b>
* <p>
* TODO: Implement me. Please.
*/
-public class TmfCoalescedDataRequest<T extends TmfEvent> extends TmfDataRequest<T> {
+public class TmfCoalescedDataRequest<T extends ITmfEvent> extends TmfDataRequest<T> {
// ------------------------------------------------------------------------
// Attributes
package org.eclipse.linuxtools.tmf.core.request;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
/**
* <p>
* TODO: Implement me. Please.
*/
-public class TmfCoalescedEventRequest<T extends TmfEvent> extends TmfCoalescedDataRequest<T> implements ITmfEventRequest<T> {
+public class TmfCoalescedEventRequest<T extends ITmfEvent> extends TmfCoalescedDataRequest<T> implements ITmfEventRequest<T> {
// ------------------------------------------------------------------------
// Attributes
import java.util.concurrent.CountDownLatch;
import org.eclipse.linuxtools.tmf.core.Tracer;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
/**
* <b><u>TmfDataRequest</u></b>
*
* TODO: Implement request failures (codes, etc...)
*/
-public abstract class TmfDataRequest<T extends TmfEvent> implements ITmfDataRequest<T> {
+public abstract class TmfDataRequest<T extends ITmfEvent> implements ITmfDataRequest<T> {
// ------------------------------------------------------------------------
// Constants
package org.eclipse.linuxtools.tmf.core.request;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
/**
* <p>
* Implement me. Please.
*/
-public abstract class TmfEventRequest<T extends TmfEvent> extends TmfDataRequest<T> implements ITmfEventRequest<T> {
+public abstract class TmfEventRequest<T extends ITmfEvent> extends TmfDataRequest<T> implements ITmfEventRequest<T> {
// ------------------------------------------------------------------------
// Attributes
package org.eclipse.linuxtools.tmf.core.signal;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.experiment.TmfExperiment;
/**
* <p>
* TODO: Implement me. Please.
*/
-public class TmfExperimentDisposedSignal<T extends TmfEvent> extends TmfSignal {
+public class TmfExperimentDisposedSignal<T extends ITmfEvent> extends TmfSignal {
private final TmfExperiment<T> fExperiment;
fExperiment = experiment;
}
- public TmfExperiment<? extends TmfEvent> getExperiment() {
+ public TmfExperiment<? extends ITmfEvent> getExperiment() {
return fExperiment;
}
package org.eclipse.linuxtools.tmf.core.signal;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.experiment.TmfExperiment;
*/
public class TmfExperimentRangeUpdatedSignal extends TmfSignal {
- private final TmfExperiment<? extends TmfEvent> fExperiment;
+ private final TmfExperiment<? extends ITmfEvent> fExperiment;
private final TmfTimeRange fTimeRange;
- public TmfExperimentRangeUpdatedSignal(Object source, TmfExperiment<? extends TmfEvent> experiment, TmfTimeRange range) { // , ITmfTrace trace) {
+ public TmfExperimentRangeUpdatedSignal(Object source, TmfExperiment<? extends ITmfEvent> experiment, TmfTimeRange range) { // , ITmfTrace trace) {
super(source);
fExperiment = experiment;
fTimeRange = range;
}
- public TmfExperiment<? extends TmfEvent> getExperiment() {
+ public TmfExperiment<? extends ITmfEvent> getExperiment() {
return fExperiment;
}
package org.eclipse.linuxtools.tmf.core.signal;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.experiment.TmfExperiment;
/**
* <p>
* TODO: Implement me. Please.
*/
-public class TmfExperimentSelectedSignal<T extends TmfEvent> extends TmfSignal {
+public class TmfExperimentSelectedSignal<T extends ITmfEvent> extends TmfSignal {
private final TmfExperiment<T> fExperiment;
fExperiment = experiment;
}
- public TmfExperiment<? extends TmfEvent> getExperiment() {
+ public TmfExperiment<? extends ITmfEvent> getExperiment() {
return fExperiment;
}
package org.eclipse.linuxtools.tmf.core.signal;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.experiment.TmfExperiment;
/**
*/
public class TmfExperimentUpdatedSignal extends TmfSignal {
- private final TmfExperiment<? extends TmfEvent> fExperiment;
+ private final TmfExperiment<? extends ITmfEvent> fExperiment;
// private final ITmfTrace fTrace;
- public TmfExperimentUpdatedSignal(Object source, TmfExperiment<? extends TmfEvent> experiment) { // , ITmfTrace trace) {
+ public TmfExperimentUpdatedSignal(Object source, TmfExperiment<? extends ITmfEvent> experiment) { // , ITmfTrace trace) {
super(source);
fExperiment = experiment;
// fTrace = trace;
}
- public TmfExperiment<? extends TmfEvent> getExperiment() {
+ public TmfExperiment<? extends ITmfEvent> getExperiment() {
return fExperiment;
}
import org.eclipse.core.resources.IProject;
import org.eclipse.linuxtools.tmf.core.component.ITmfComponent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
/**
* <b><u>ITmfTrace</u></b>
* <p>
*/
-public interface ITmfTrace<T extends TmfEvent> extends ITmfComponent {
+public interface ITmfTrace<T extends ITmfEvent> extends ITmfComponent {
// initTrace variants
public void initTrace(String name, String path, Class<T> eventType) throws FileNotFoundException;
*
* @return the next event in the stream
*/
- public TmfEvent getNextEvent(TmfContext context);
+ public ITmfEvent getNextEvent(TmfContext context);
/**
* Return the event pointed by the supplied context (or null if no event left) and *does not* update the context.
*
* @return the next event in the stream
*/
- public TmfEvent parseEvent(TmfContext context);
+ public ITmfEvent parseEvent(TmfContext context);
}
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.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest;
*
* TODO: Add support for live streaming (notifications, incremental indexing, ...)
*/
-public abstract class TmfTrace<T extends TmfEvent> extends TmfEventProvider<T> implements ITmfTrace<T>, Cloneable {
+public abstract class TmfTrace<T extends ITmfEvent> extends TmfEventProvider<T> implements ITmfTrace<T>, Cloneable {
// ------------------------------------------------------------------------
// Constants
// And locate the event
TmfContext nextEventContext = context.clone(); // Must use clone() to get the right subtype...
- TmfEvent event = getNextEvent(nextEventContext);
+ ITmfEvent event = getNextEvent(nextEventContext);
while (event != null && event.getTimestamp().compareTo(timestamp, false) < 0) {
context.setLocation(nextEventContext.getLocation().clone());
context.updateRank(1);
context.setRank(pos);
if (pos < rank) {
- TmfEvent event = getNextEvent(context);
+ ITmfEvent event = getNextEvent(context);
while (event != null && ++pos < rank) {
event = getNextEvent(context);
}
* linuxtools.tmf.trace.ITmfTrace.TraceContext)
*/
@Override
- public synchronized TmfEvent getNextEvent(TmfContext context) {
+ public synchronized ITmfEvent getNextEvent(TmfContext context) {
// parseEvent() does not update the context
- TmfEvent event = parseEvent(context);
+ ITmfEvent event = parseEvent(context);
if (event != null) {
updateIndex(context, context.getRank(), event.getTimestamp());
context.setLocation(getCurrentLocation());
*
* @param event
*/
- protected void processEvent(TmfEvent event) {
+ protected void processEvent(ITmfEvent event) {
// Do nothing by default
}
job.schedule();
fCheckpoints.clear();
- ITmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, TmfTimeRange.Eternity, TmfDataRequest.ALL_DATA,
+ ITmfEventRequest<ITmfEvent> request = new TmfEventRequest<ITmfEvent>(ITmfEvent.class, TmfTimeRange.Eternity, TmfDataRequest.ALL_DATA,
fIndexPageSize, ITmfDataRequest.ExecutionType.BACKGROUND) {
ITmfTimestamp startTime = null;
ITmfTimestamp lastTime = null;
@Override
- public void handleData(TmfEvent event) {
+ public void handleData(ITmfEvent event) {
super.handleData(event);
if (event != null) {
ITmfTimestamp ts = event.getTimestamp();
}
- private TmfTraceStub setupTrace(ITmfEventParser parser) {
+ private TmfTraceStub setupTrace(ITmfEventParser<TmfEvent> parser) {
try {
// Create test trace object
import org.eclipse.linuxtools.tmf.core.trace.TmfLocation;
import org.eclipse.linuxtools.tmf.stubs.trace.TmfTraceStub;
-public class TmfUml2SDTestTrace implements ITmfEventParser {
+public class TmfUml2SDTestTrace implements ITmfEventParser<TmfEvent> {
@Override
@SuppressWarnings({ "unchecked", "nls" })
- public TmfEvent parseNextEvent(ITmfTrace<?> eventStream, TmfContext context) throws IOException {
+ public TmfEvent parseNextEvent(ITmfTrace<TmfEvent> eventStream, TmfContext context) throws IOException {
if (! (eventStream instanceof TmfTraceStub)) {
return null;
}
\r
import java.util.ArrayList;\r
\r
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;\r
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;\r
import org.eclipse.linuxtools.tmf.ui.TmfUiPlugin;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.widgets.TraceColorScheme;\r
import org.eclipse.swt.SWT;\r
fireColorSettingsChanged();\r
}\r
\r
- public static ColorSetting getColorSetting(TmfEvent event) {\r
+ public static ColorSetting getColorSetting(ITmfEvent event) {\r
for (int i = 0; i < fColorSettings.length; i++) {\r
ColorSetting colorSetting = fColorSettings[i];\r
if (colorSetting.getFilter() != null && colorSetting.getFilter().matches(event)) {\r
return DEFAULT_COLOR_SETTING;\r
}\r
\r
- public static int getColorSettingPriority(TmfEvent event) {\r
+ public static int getColorSettingPriority(ITmfEvent event) {\r
for (int i = 0; i < fColorSettings.length; i++) {\r
ColorSetting colorSetting = fColorSettings[i];\r
if (colorSetting.getFilter() != null && colorSetting.getFilter().matches(event)) {\r
import org.eclipse.jface.viewers.TreeViewerColumn;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerComparator;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.experiment.TmfExperiment;
import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest;
+import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest.ExecutionType;
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.request.ITmfDataRequest.ExecutionType;
import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentDisposedSignal;
import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentRangeUpdatedSignal;
import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentSelectedSignal;
// The actual tree to display
protected TreeViewer fTreeViewer;
// Stores the request to the experiment
- protected ITmfEventRequest<TmfEvent> fRequest = null;
+ protected ITmfEventRequest<ITmfEvent> fRequest = null;
// Update synchronization parameters (used for streaming)
protected boolean fStatisticsUpdateBusy = false;
* @param signal
*/
@TmfSignalHandler
- public void experimentDisposed(TmfExperimentDisposedSignal<? extends TmfEvent> signal) {
+ public void experimentDisposed(TmfExperimentDisposedSignal<? extends ITmfEvent> signal) {
if (signal.getExperiment() != TmfExperiment.getCurrentExperiment()) {
return;
}
* contains the information about the selection.
*/
@TmfSignalHandler
- public void experimentSelected(TmfExperimentSelectedSignal<? extends TmfEvent> signal) {
+ public void experimentSelected(TmfExperimentSelectedSignal<? extends ITmfEvent> signal) {
if (signal != null) {
TmfExperiment<?> experiment = signal.getExperiment();
String experimentName = experiment.getName();
@SuppressWarnings("unchecked")
@TmfSignalHandler
public void experimentRangeUpdated(TmfExperimentRangeUpdatedSignal signal) {
- TmfExperiment<TmfEvent> experiment = (TmfExperiment<TmfEvent>) signal.getExperiment();
+ TmfExperiment<ITmfEvent> experiment = (TmfExperiment<ITmfEvent>) signal.getExperiment();
// validate
if (! experiment.equals(TmfExperiment.getCurrentExperiment())) {
return;
}
// Preparation of the event request
- fRequest = new TmfEventRequest<TmfEvent>(TmfEvent.class, timeRange, index, TmfDataRequest.ALL_DATA, getIndexPageSize(), ExecutionType.BACKGROUND) {
+ fRequest = new TmfEventRequest<ITmfEvent>(ITmfEvent.class, timeRange, index, TmfDataRequest.ALL_DATA, getIndexPageSize(), ExecutionType.BACKGROUND) {
@Override
- public void handleData(TmfEvent data) {
+ public void handleData(ITmfEvent data) {
super.handleData(data);
if (data != null) {
AbsTmfStatisticsTree statisticsData = TmfStatisticsTreeRootFactory.getStatTree(getTreeID(experiment.getName()));
modelIncomplete(experiment.getName());
}
};
- ((TmfExperiment<TmfEvent>) experiment).sendRequest((ITmfDataRequest<TmfEvent>) fRequest);
+ ((TmfExperiment<ITmfEvent>) experiment).sendRequest((ITmfDataRequest<ITmfEvent>) fRequest);
waitCursor(true);
}
}
import java.util.Map;
import java.util.Set;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.util.TmfFixedArray;
import org.eclipse.linuxtools.tmf.ui.views.statistics.ITmfExtraEventInfo;
* @param values
* Values desired.
*/
- public abstract void increase(TmfEvent event, ITmfExtraEventInfo extraInfo, int values);
+ public abstract void increase(ITmfEvent event, ITmfExtraEventInfo extraInfo, int values);
/**
* <h4>Register an event.</h4>
* @param extraInfo
* Extra information to pass along with the event.
*/
- public abstract void registerEvent(TmfEvent event, ITmfExtraEventInfo extraInfo);
+ public abstract void registerEvent(ITmfEvent event, ITmfExtraEventInfo extraInfo);
/**
* <h4>Register that a new node was created.</h4>
import java.util.Map;
import java.util.Set;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.util.TmfFixedArray;
import org.eclipse.linuxtools.tmf.ui.views.statistics.ITmfExtraEventInfo;
* @return Array of FixedArray representing the paths.
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
- protected TmfFixedArray<String>[] getTypePaths(TmfEvent event, ITmfExtraEventInfo extraInfo) {
+ protected TmfFixedArray<String>[] getTypePaths(ITmfEvent event, ITmfExtraEventInfo extraInfo) {
String trace = extraInfo.getTraceName();
// String type = event.getType().getTypeId(); // Add too much
// informations
* @return Array of FixedArray representing the paths.
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
- protected TmfFixedArray<String>[] getNormalPaths(TmfEvent event, ITmfExtraEventInfo extraInfo) {
+ protected TmfFixedArray<String>[] getNormalPaths(ITmfEvent event, ITmfExtraEventInfo extraInfo) {
String trace = extraInfo.getTraceName();
TmfFixedArray[] paths = { new TmfFixedArray<String>(trace) };
* @see org.eclipse.linuxtools.tmf.ui.views.statistics.model.TmfStatisticsData#increase(org.eclipse.linuxtools.tmf.event.TmfEvent, org.eclipse.linuxtools.tmf.ui.views.statistics.ITmfEventInfo, int)
*/
@Override
- public void increase(TmfEvent event, ITmfExtraEventInfo extraInfo, int values) {
+ public void increase(ITmfEvent event, ITmfExtraEventInfo extraInfo, int values) {
// Do nothing
}
* @see org.eclipse.linuxtools.tmf.ui.views.statistics.model.TmfStatisticsData#registerEvent(org.eclipse.linuxtools.tmf.event.TmfEvent, org.eclipse.linuxtools.tmf.ui.views.statistics.ITmfEventInfo)
*/
@Override
- public void registerEvent(TmfEvent event, ITmfExtraEventInfo extraInfo) {
+ public void registerEvent(ITmfEvent event, ITmfExtraEventInfo extraInfo) {
TmfFixedArray<String>[] paths = getNormalPaths(event, extraInfo);
for (TmfFixedArray<String> path : paths)
++(getOrCreate(path).getValue().nbEvents);
import org.eclipse.core.resources.IMarker;\r
import org.eclipse.core.resources.IResource;\r
import org.eclipse.core.runtime.CoreException;\r
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;\r
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;\r
import org.eclipse.linuxtools.tmf.core.filter.ITmfFilter;\r
\r
public class TimeChartDecorationProvider {\r
fFilterFilter = filter;\r
}\r
\r
- public boolean isVisible(TmfEvent event) {\r
+ public boolean isVisible(ITmfEvent event) {\r
if (fFilterFilter != null) {\r
return fFilterFilter.matches(event);\r
}\r
fSearchFilter = filter;\r
}\r
\r
- public boolean isSearchMatch(TmfEvent event) {\r
+ public boolean isSearchMatch(ITmfEvent event) {\r
if (fSearchFilter != null) {\r
return fSearchFilter.matches(event);\r
}\r
import java.util.ArrayList;\r
import java.util.Iterator;\r
\r
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;\r
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;\r
import org.eclipse.linuxtools.tmf.ui.views.colors.ColorSettingsManager;\r
private TimeChartAnalysisEntry fItemizedEntry;\r
private boolean fItemizing;\r
\r
- public TimeChartEvent(TimeChartAnalysisEntry parentEntry, TmfEvent event, long rank, TimeChartDecorationProvider decorationProvider) {\r
+ public TimeChartEvent(TimeChartAnalysisEntry parentEntry, ITmfEvent event, long rank, TimeChartDecorationProvider decorationProvider) {\r
fParentEntry = parentEntry;\r
fTime = event.getTimestamp().normalize(0, TIMESTAMP_SCALE).getValue();\r
fDuration = 0;\r
import org.eclipse.core.resources.IResourceChangeListener;\r
import org.eclipse.core.resources.IResourceDelta;\r
import org.eclipse.core.resources.ResourcesPlugin;\r
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;\r
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;\r
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;\r
import org.eclipse.linuxtools.tmf.core.filter.ITmfFilter;\r
import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;\r
}\r
while (true) {\r
long rank = context.getRank();\r
- TmfEvent event = trace.getNextEvent(context);\r
+ ITmfEvent event = trace.getNextEvent(context);\r
if (event == null) {\r
done = true;\r
break;\r
if (interrupted)\r
return;\r
long rank = fContext.getRank();\r
- TmfEvent event = trace.getNextEvent(fContext);\r
+ ITmfEvent event = trace.getNextEvent(fContext);\r
if (event == null) {\r
break;\r
}\r
\r
import java.util.ArrayList;\r
\r
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;\r
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;\r
import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation;\r
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;\r
import org.eclipse.linuxtools.tmf.core.trace.TmfContext;\r
long rank = 0;\r
while (!context.getLocation().equals(endLocation)) {\r
location = context.getLocation().clone();\r
- TmfEvent event = fTrace.getNextEvent(context);\r
+ ITmfEvent event = fTrace.getNextEvent(context);\r
if (event == null) {\r
break;\r
}\r
}\r
long rank = fBottomContext.getRank();\r
ITmfLocation<?> location = fBottomContext.getLocation() != null ? fBottomContext.getLocation().clone() : null;\r
- TmfEvent event = fTrace.getNextEvent(fBottomContext);\r
+ ITmfEvent event = fTrace.getNextEvent(fBottomContext);\r
if (event == null) {\r
break;\r
}\r
projects / deliverable / tracecompass.git / commitdiff
