LttngEventContent testContent = null;
LttngEventContent testContent2 = null;
LttngEventField[] testFields = new LttngEventField[1];
- testFields[0] = new LttngEventField(testContent2, "test");
+ testFields[0] = new LttngEventField("test");
// Default construction with good argument
try {
tmpEvent = (LttngEvent)tmpStream.getNextEvent(tmpContext);
testContent = prepareToTest();
// getFieldS()
- assertNotSame("getFields() returned null!",null,testContent.getFields() );
+ assertNotSame("getFields() returned null!", null, testContent.getFields() );
// *** FIXME ***
// Depending from the Java version because of the "hashcode()" on String.
//
// getField(int)
//assertEquals("getField(int) returned unexpected result!",firstEventContentFirstField, testContent.getField(0).toString());
- assertNotSame("getField(int) returned unexpected result!",null, testContent.getField(0).toString());
+ assertNotSame("getField(int) returned unexpected result!", null, testContent.getField(0).toString());
// getField(name)
// Test that get event return the correct event
assertTrue("getEvent() returned unexpected result!", tmpEvent.getTimestamp().getValue() == testContent.getEvent().getTimestamp().getValue());
// getType()
- assertEquals("getType() returned unexpected result!",firstEventContentType, testContent.getType().toString());
+ assertEquals("getType() returned unexpected result!",firstEventContentType, testContent.getEvent().getType().toString());
//*** To test getFields with a fields number >0, we need to move to an event that have some more
tmpStream = initializeEventStream();
// Test that get event return the correct event
assertTrue("getEvent() returned unexpected result!",tmpEvent.getTimestamp().getValue() == testContent.getEvent().getTimestamp().getValue());
// getType()
- assertEquals("getType() returned unexpected result!",secondEventContentType, testContent.getType().toString());
+ assertEquals("getType() returned unexpected result!",secondEventContentType, testContent.getEvent().getType().toString());
// getFieldS()
- assertNotSame("getFields() returned null!",null,testContent.getFields() );
+ assertNotSame("getFields() returned null!", null, testContent.getFields() );
// getField(int)
assertEquals("getField(int) returned unexpected result!",secondEventContentSecondField, testContent.getField(1).toString());
// getField(name)
assertEquals("getField(name) returned unexpected result!",secondEventContentSecondField, testContent.getField(secondEventContentSecondFieldName).toString());
// getRawContent
- assertNotSame("getRawContent() returned null!",null, testContent.getMapContent());
+ assertNotSame("getRawContent() returned null!", null, testContent.getMapContent());
}
LttngEventType testType = new LttngEventType();
try {
- tmpContent.setType(testType);
+ tmpContent.getEvent().setType(testType);
}
catch( Exception e) {
fail("setType(type) failed!");
import org.eclipse.linuxtools.lttng.core.event.LttngEventField;
import org.eclipse.linuxtools.lttng.core.tests.LTTngCoreTestPlugin;
import org.eclipse.linuxtools.lttng.core.trace.LTTngTextTrace;
-import org.eclipse.linuxtools.tmf.core.event.TmfNoSuchFieldException;
import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
import org.eclipse.linuxtools.tmf.core.trace.TmfLocation;
// Default construction with good argument
try {
- testField = new LttngEventField(testContent, "test", "test");
+ testField = new LttngEventField("test", "test");
}
catch( Exception e) {
fail("Default construction failed!");
// Copy constructor with correct parameters
try {
- testField = new LttngEventField(testContent, "test", "test");
+ testField = new LttngEventField("test", "test");
testField2 = new LttngEventField(testField);
}
catch( Exception e) {
LTTngTextTrace tmpStream = initializeEventStream();
LttngEventField testField = null;
- try {
+// try {
testField = (LttngEventField) tmpStream.getNextEvent( new TmfContext(new TmfLocation<Long>(0L), 0) ).getContent().getField(0);
- } catch (TmfNoSuchFieldException e) {
- e.printStackTrace();
- }
+// } catch (TmfNoSuchFieldException e) {
+// e.printStackTrace();
+// }
assertNotSame("getField is null!", null, testField);
// *** FIXME ***
// We can't really test that safetly
//
//assertTrue("getName() returned unexpected result!",firstEventName.equals(testField.getId().toString()));
- assertNotSame("getName() returned unexpected result!",null, testField.getId());
+ assertNotSame("getName() returned unexpected result!",null, testField.getName());
assertTrue("getValue() returned unexpected result!",firstEventValue.equals(testField.getValue().toString()));
try {
// In order to test LttngEvent, we need all these constructors/functions to work.
// Make sure to run their unit tests first!
- testMarkerFields = new String[1];
+ testMarkerFields = new String[] { "test" };
testEvent = null;
testTime = new LttngTimestamp(0L);
testSource = "test";
assertEquals("Reference not what expected!", eventReference, testEvent.getReference());
// These should be overridden functions
- assertEquals("Type not what expected!",eventType,testEvent.getType().getId());
+ assertEquals("Type not what expected!",eventType,testEvent.getType().getName());
assertEquals("Channel not what expected!",eventChannel,testEvent.getChannelName());
assertEquals("CpuId not what expected!",eventCpu,testEvent.getCpuId());
assertEquals("Marker not what expected!",eventMarker,testEvent.getMarkerName());
LttngEventContent testContent = null;
JniEvent testJniEvent = null;
- String[] testMarkerFields = new String[1];
+ String[] testMarkerFields = new String[] { "test" };
testType = new LttngEventType("test", 0L, "test", 0, testMarkerFields);
testContent = new LttngEventContent(testEvent);
// Default construction with good arguments
try {
- tmpEventType = new LttngEventType("test", 0L, "test", 0, new String[1]);
+ tmpEventType = new LttngEventType("test", 0L, "test", 0, new String[] { "test" });
}
- catch( Exception e) {
+ catch (Exception e) {
fail("Construction failed!");
}
// Copy constructor
try {
- tmpEventType = new LttngEventType("test", 0L, "test", 0, new String[1]);
+ tmpEventType = new LttngEventType("test", 0L, "test", 0, new String[] { "test" });
tmpEventType2 = new LttngEventType(tmpEventType);
}
- catch( Exception e) {
+ catch (Exception e) {
fail("Construction failed!");
}
}
assertTrue("Cpu Id not what was expected!",firstEventCpu == tmpEventType.getCpuId() );
assertTrue("Marker Name not what was expected!",firstEventMarker.equals((String)tmpEventType.getMarkerName()) );
// Just test the non-nullity of labels
- assertNotSame("getLabels returned null",null, tmpEventType.getFieldLabels() );
+ assertNotSame("getLabels returned null",null, tmpEventType.getFieldNames() );
}
public void testToString() {
String expectedFieldName = expectedField.getInName();
for (int i = 0; i < fields.length; i++) {
field = (LttngEventField) fields[i];
- fieldname = field.getId();
+ fieldname = field.getName();
if (fieldname.equals(expectedFieldName)) {
Object fieldObj = field.getValue();
if (fieldObj instanceof Long) {
String expectedFieldName = expectedField.getInName();
for (int i = 0; i < fields.length; i++) {
field = (LttngEventField) fields[i];
- fieldname = field.getId();
+ fieldname = field.getName();
if (fieldname.equals(expectedFieldName)) {
Object fieldObj = field.getValue();
if (fieldObj instanceof String) {
sb.append(" number of fields: " + fields.length + "Fields: ");
for (int i = 0; i < fields.length; i++) {
field = (LttngEventField) fields[i];
- sb.append(field.getId() + " ");
+ sb.append(field.getName() + " ");
}
TraceDebug.debug(sb.toString(), 5);
String expectedFieldName = expectedField.getInName();
for (int i = 0; i < fields.length; i++) {
field = (LttngEventField) fields[i];
- fieldname = field.getId();
+ fieldname = field.getName();
if (fieldname.equals(expectedFieldName)) {
Object fieldObj = field.getValue();
if (fieldObj instanceof Long) {
String expectedFieldName = expectedField.getInName();
for (int i = 0; i < fields.length; i++) {
field = (LttngEventField) fields[i];
- fieldname = field.getId();
+ fieldname = field.getName();
if (fieldname.equals(expectedFieldName)) {
Object fieldObj = field.getValue();
if (fieldObj instanceof String) {
sb.append(" number of fields: " + fields.length + "Fields: ");
for (int i = 0; i < fields.length; i++) {
field = (LttngEventField) fields[i];
- sb.append(field.getId() + " ");
+ sb.append(field.getName() + " ");
}
TraceDebug.debug(sb.toString(), 5);
import java.util.HashMap;
import org.eclipse.linuxtools.lttng.jni.JniEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventContent;
-import org.eclipse.linuxtools.tmf.core.event.TmfNoSuchFieldException;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
+import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
/**
* <b><u>LttngEventContent</u></b><p>
*
* Lttng specific implementation of the TmfEventContent.<p>
*/
-public class LttngEventContent extends TmfEventContent {
+public class LttngEventContent extends TmfEventField {
+
+ private LttngEvent fParentEvent;
// Hash map that contain the (parsed) fields. This is the actual payload of the event.
- HashMap<String, LttngEventField> fFieldsMap = new HashMap<String, LttngEventField>();
+ private HashMap<String, LttngEventField> fFieldsMap = new HashMap<String, LttngEventField>();
/**
* Default constructor.<p>
*
- *
*/
public LttngEventContent() {
- super(null, null);
+ super(ITmfEventField.ROOT_ID, null);
}
/**
* @see org.eclipse.linuxtools.lttng.core.event.LttngEvent
*/
public LttngEventContent(LttngEvent thisParent) {
- super(thisParent, null);
+ super(ITmfEventField.ROOT_ID, null);
+ fParentEvent = thisParent;
}
/**
* @see org.eclipse.linuxtools.lttng.core.event.LttngEvent
*/
public LttngEventContent(LttngEvent thisParent, HashMap<String, LttngEventField> thisContent) {
- super(thisParent, null);
-
+ super(ITmfEventField.ROOT_ID, null);
+ fParentEvent = thisParent;
fFieldsMap = thisContent;
}
* @param oldContent Content to copy from
*/
public LttngEventContent(LttngEventContent oldContent) {
- this((LttngEvent)oldContent.getEvent(), oldContent.getMapContent() );
+ this((LttngEvent) oldContent.getEvent(), oldContent.getMapContent());
}
-
- @Override
public LttngEvent getEvent() {
- return (LttngEvent)fParentEvent;
+ return fParentEvent;
}
public void setEvent(LttngEvent newParent) {
// *** VERIFY ***
// These are not very useful, are they?
- @Override
- public LttngEventType getType() {
- return (LttngEventType)fParentEvent.getType();
- }
- public void setType(LttngEventType newType) {
- ((LttngEvent)fParentEvent).setType(newType);
- }
+
+// public LttngEventType getType() {
+// return (LttngEventType)fParentEvent.getType();
+// }
+
+// public void setType(LttngEventType newType) {
+// ((LttngEvent)fParentEvent).setType(newType);
+// }
// ***TODO***
*
* @return Currently parsed fields.
*/
- @Override
public Object[] getRawContent() {
- Object[] returnedContent = fFieldsMap.values().toArray( new Object[fFieldsMap.size()] );
-
+ Object[] returnedContent = fFieldsMap.values().toArray(new Object[fFieldsMap.size()]);
return returnedContent;
}
*/
@Override
public synchronized LttngEventField[] getFields() {
- if (fFieldsMap.size() < fParentEvent.getType().getNbFields()) {
+ int nbFields = fParentEvent.getType().getFieldNames().length;
+
+ if (fFieldsMap.size() < nbFields) {
LttngEventField tmpField = null;
LttngEventType tmpType = (LttngEventType)fParentEvent.getType();
- for ( int pos=0; pos<tmpType.getNbFields(); pos++ ) {
+ for (int pos=0; pos < nbFields; pos++) {
String name = null;
LttngEvent lttngTmpEvent = (LttngEvent)getEvent(); //added for easier debugging
JniEvent tmpEvent = (lttngTmpEvent).convertEventTmfToJni();
// tmpEvent == null probably mean there is a discrepancy between Eclipse and C library
// An error was probably printed in convertEventTmfToJni() already, but keep in mind this is SERIOUS
if ( tmpEvent != null ) {
- try {
- name = tmpType.getFieldLabel(pos);
+// try {
+ name = tmpType.getFieldName(pos);
Object newValue = tmpEvent.parseFieldByName(name);
- tmpField = new LttngEventField(this, name, newValue );
+ tmpField = new LttngEventField(name, newValue, null);
fFieldsMap.put(name, tmpField);
- }
- catch (TmfNoSuchFieldException e) {
- System.out.println("Invalid field position requested : " + pos + ", ignoring (getFields)."); //$NON-NLS-1$//$NON-NLS-2$
- }
+// }
+// catch (TmfNoSuchFieldException e) {
+// System.out.println("Invalid field position requested : " + pos + ", ignoring (getFields)."); //$NON-NLS-1$//$NON-NLS-2$
+// }
}
}
}
public LttngEventField getField(int position) {
LttngEventField returnedField = null;
String label = null;
- try {
- label = fParentEvent.getType().getFieldLabel(position);
-
+// try {
+ label = fParentEvent.getType().getFieldName(position);
returnedField = (LttngEventField) this.getField(label);
- }
- catch (TmfNoSuchFieldException e) {
- System.out.println("Invalid field position requested : " + position + ", ignoring (getField)."); //$NON-NLS-1$//$NON-NLS-2$
- }
+// }
+// catch (TmfNoSuchFieldException e) {
+// System.out.println("Invalid field position requested : " + position + ", ignoring (getField)."); //$NON-NLS-1$//$NON-NLS-2$
+// }
return returnedField;
}
public synchronized LttngEventField getField(String name) {
// Check for generic table header fields
- if (name.equals(LttngEventType.CONTENT_LABEL) || name.equals(FIELD_ID_CONTENT)) {
- return new LttngEventField(this, toString());
- } else if (name.equals(LttngEventType.MARKER_LABEL) || name.equals(FIELD_ID_TYPE)) {
- return new LttngEventField(this, fParentEvent.getType().getId());
- } else if (name.equals(LttngEventType.TRACE_LABEL) || name.equals(FIELD_ID_REFERENCE)) {
- return new LttngEventField(this, fParentEvent.getReference());
- } else if (name.equals(LttngEventType.TIMESTAMP_LABEL) || name.equals(FIELD_ID_TIMESTAMP)) {
- return new LttngEventField(this, fParentEvent.getTimestamp().toString());
- } else if (name.equals(FIELD_ID_SOURCE)) {
- return new LttngEventField(this, fParentEvent.getSource());
+ if (name.equals(LttngEventType.CONTENT_LABEL) || name.equals(ITmfEvent.EVENT_FIELD_CONTENT)) {
+ return new LttngEventField(toString());
+ } else if (name.equals(LttngEventType.MARKER_LABEL) || name.equals(ITmfEvent.EVENT_FIELD_TYPE)) {
+ return new LttngEventField(fParentEvent.getType().getName());
+ } else if (name.equals(LttngEventType.TRACE_LABEL) || name.equals(ITmfEvent.EVENT_FIELD_REFERENCE)) {
+ return new LttngEventField(fParentEvent.getReference());
+ } else if (name.equals(LttngEventType.TIMESTAMP_LABEL) || name.equals(ITmfEvent.EVENT_FIELD_TIMESTAMP)) {
+ return new LttngEventField(fParentEvent.getTimestamp().toString());
+ } else if (name.equals(ITmfEvent.EVENT_FIELD_SOURCE)) {
+ return new LttngEventField(fParentEvent.getSource());
}
// *** VERIFY ***
Object newValue = tmpEvent.parseFieldByName(name);
if ( newValue!= null ) {
- returnedField = new LttngEventField(this, name, newValue);
+ returnedField = new LttngEventField(name, newValue);
+ returnedField = new LttngEventField(name, newValue);
fFieldsMap.put(name, returnedField );
}
}
return returnedField;
}
- // *** VERIFY ***
- // *** Is this even useful?
- @Override
- protected void parseContent() {
- fFields = getFields();
- }
+// // *** VERIFY ***
+// // *** Is this even useful?
+// protected void parseContent() {
+// fSubfields = getFields();
+// }
/**
* toString() method to print the content
public LttngEventContent clone() {
LttngEventContent clone = (LttngEventContent) super.clone();
LttngEventField[] fields = getFields();
- clone.fFields = new LttngEventField[fields.length];
+ LttngEventField[] subfields = new LttngEventField[fields.length];
for (int i = 0; i < fields.length; i++) {
- clone.fFields[i] = fields[i].clone();
+ subfields[i] = (LttngEventField) fields[i].clone();
}
+ clone.setValue(getValue(), subfields);
clone.fFieldsMap = new HashMap<String, LttngEventField>();
for (String key : fFieldsMap.keySet()) {
clone.fFieldsMap.put(new String(key), ((LttngEventField) fFieldsMap.get(key)).clone());
package org.eclipse.linuxtools.lttng.core.event;
-import org.eclipse.linuxtools.tmf.core.event.ITmfEventContent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventContent;
import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
/**
* mean the fields will have a name and a value.
*/
public class LttngEventField extends TmfEventField {
-
- /**
- * Constructor with parameters.<p>
- *
- * @param parent Parent content for this field
- * @param id Name (label) of this field
- */
- public LttngEventField(TmfEventContent parent, String id) {
- super(parent, id, null);
+
+ public LttngEventField(String name, Object value, LttngEventField[] subfields) {
+ super(name, value, subfields);
+ }
+
+ public LttngEventField(String name, Object value) {
+ this(name, value, null);
}
- /**
- * Constructor with parameters with optional value.<p>
- *
- * @param parent Parent content for this field
- * @param id Name (label) of this field
- * @param value Parsed value (payload) of this field
- */
- public LttngEventField(ITmfEventContent parent, String id, Object value) {
- super(parent, id, value);
- }
-
- /**
- * Copy constructor.<p>
- *
- * @param oldField the field to copy from
- */
- public LttngEventField(LttngEventField oldField) {
- this(oldField.getContent(), oldField.getId(), oldField.getValue());
- }
-
- @Override
- @SuppressWarnings("nls")
- public String toString() {
- Object value = getValue();
- return getId() + ":" + ((value != null) ? value.toString() : "null");
- }
-
- @Override
- public LttngEventField clone() {
- LttngEventField clone = (LttngEventField) super.clone();
- clone.fValue = fValue;
- return clone;
- }
-
+ public LttngEventField(String name) {
+ this(name, null, null);
+ }
+
+ public LttngEventField(LttngEventField field) {
+ super(field);
+ }
+
+ @Override
+ public LttngEventField clone() {
+ LttngEventField clone = null;
+ clone = (LttngEventField) super.clone();
+ return clone;
+ }
+
+ @Override
+ public String toString() {
+ return getName() + ":" + getValue(); //$NON-NLS-1$
+ }
}
*
*/
public LttngEventType(String typeId, String[] labels) {
- super(DEFAULT_CONTEXT, typeId, labels);
+ super(DEFAULT_CONTEXT, typeId, TmfEventField.makeRoot(labels));
}
/**
* @param thisMarkerfieldsName MarkerFields related to this marker
*/
public LttngEventType(String thisTracefileName, Long thisCpuId, String thisMarkerName, int thisMarkerId, String[] thisMarkerfieldsName) {
- super(DEFAULT_CONTEXT, thisTracefileName + "/" + thisCpuId + "/" + thisMarkerName, thisMarkerfieldsName); //$NON-NLS-1$ //$NON-NLS-2$
+ super(DEFAULT_CONTEXT, thisTracefileName + "/" + thisCpuId + "/" + thisMarkerName, TmfEventField.makeRoot(thisMarkerfieldsName)); //$NON-NLS-1$ //$NON-NLS-2$
tracefileName = thisTracefileName;
cpuId = thisCpuId;
* @param oldType Type we want to copy from
*/
public LttngEventType(LttngEventType oldType) {
- this(oldType.tracefileName, oldType.cpuId, oldType.markerName, oldType.markerId, oldType.getFieldLabels());
+ this(oldType.tracefileName, oldType.cpuId, oldType.markerName, oldType.markerId, oldType.getFieldNames());
}
import org.eclipse.linuxtools.lttng.core.LttngConstants;
import org.eclipse.linuxtools.lttng.core.TraceDebug;
-import org.eclipse.linuxtools.tmf.core.event.TmfDataItem;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
+import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
public abstract class LTTngTreeNodeGeneric<E extends LTTngTreeNodeGeneric<E>>
- extends TmfDataItem implements ILTTngTreeNode<E> {
+ extends TmfEvent implements ILTTngTreeNode<E> {
// ========================================================================
// Data
sb.append(" number of fields: " + fields.length + "Fields: ");
for (int i = 0; i < fields.length; i++) {
field = (LttngEventField) fields[i];
- sb.append(field.getId() + " ");
+ sb.append(field.getName() + " ");
}
TraceDebug.debug(sb.toString(), 5);
import org.eclipse.linuxtools.lttng.core.event.LttngEventType;
import org.eclipse.linuxtools.lttng.core.event.LttngTimestamp;
import org.eclipse.linuxtools.lttng.jni.JniEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfNoSuchFieldException;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation;
import org.eclipse.linuxtools.tmf.core.trace.TmfCheckpoint;
}
catch (NumberFormatException e) { }
- LttngEventField tmpField = new LttngEventField(eventContent, markerName, payload);
+ LttngEventField tmpField = new LttngEventField(markerName, payload);
fieldsMap.put(markerName, tmpField);
tmpIndexBegin = tmpIndexEnd+1;
markerName = ""; //$NON-NLS-1$
payload = ""; //$NON-NLS-1$
- LttngEventField tmpField = new LttngEventField(eventContent, markerName, payload);
+ LttngEventField tmpField = new LttngEventField(markerName, payload);
fieldsMap.put(markerName, tmpField);
}
}
public TextLttngEventContent(TextLttngEventContent oldContent) {
- this( (TextLttngEvent)oldContent.fParentEvent, oldContent.getMapContent());
+ this(((TextLttngEvent) oldContent.getEvent()), oldContent.getMapContent());
}
@Override
public LttngEventField getField(int position) {
LttngEventField returnedField = null;
String label = null;
- try {
- label = fParentEvent.getType().getFieldLabel(position);
+// try {
+ label = getEvent().getType().getFieldName(position);
returnedField = this.getField(label);
- }
- catch (TmfNoSuchFieldException e) {
- System.out.println("Invalid field position requested : " + position + ", ignoring (getField)."); //$NON-NLS-1$ //$NON-NLS-2$
- }
+// }
+// catch (TmfNoSuchFieldException e) {
+// System.out.println("Invalid field position requested : " + position + ", ignoring (getField)."); //$NON-NLS-1$ //$NON-NLS-2$
+// }
return returnedField;
}
\r
package org.eclipse.linuxtools.lttng.ui.views.events;\r
\r
-import org.eclipse.linuxtools.tmf.core.event.ITmfEventContent;\r
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;\r
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;\r
-import org.eclipse.linuxtools.tmf.core.event.TmfEventContent;\r
import org.eclipse.linuxtools.tmf.core.event.TmfEventField;\r
import org.eclipse.linuxtools.tmf.ui.viewers.events.TmfEventsTable;\r
import org.eclipse.linuxtools.tmf.ui.widgets.ColumnData;\r
\r
public EventsTable(Composite parent, int cacheSize) {\r
super(parent, cacheSize, COLUMN_DATA);\r
- fTable.getColumns()[0].setData(Key.FIELD_ID, TmfEventContent.FIELD_ID_TIMESTAMP);\r
- fTable.getColumns()[1].setData(Key.FIELD_ID, TmfEventContent.FIELD_ID_REFERENCE);\r
- fTable.getColumns()[2].setData(Key.FIELD_ID, TmfEventContent.FIELD_ID_TYPE);\r
- fTable.getColumns()[3].setData(Key.FIELD_ID, TmfEventContent.FIELD_ID_CONTENT);\r
+ fTable.getColumns()[0].setData(Key.FIELD_ID, ITmfEvent.EVENT_FIELD_TIMESTAMP);\r
+ fTable.getColumns()[1].setData(Key.FIELD_ID, ITmfEvent.EVENT_FIELD_REFERENCE);\r
+ fTable.getColumns()[2].setData(Key.FIELD_ID, ITmfEvent.EVENT_FIELD_TYPE);\r
+ fTable.getColumns()[3].setData(Key.FIELD_ID, ITmfEvent.EVENT_FIELD_CONTENT);\r
}\r
\r
/**\r
protected TmfEventField[] extractItemFields(TmfEvent event) {\r
TmfEventField[] fields = new TmfEventField[0];\r
if (event != null) {\r
- ITmfEventContent content = event.getContent();\r
fields = new TmfEventField[] {\r
- new TmfEventField(content, TmfEventContent.FIELD_ID_TIMESTAMP, ((Long) event.getTimestamp().getValue()).toString()),\r
- new TmfEventField(content, TmfEventContent.FIELD_ID_REFERENCE, event.getReference()),\r
- new TmfEventField(content, TmfEventContent.FIELD_ID_TYPE, event.getType().getId()),\r
- new TmfEventField(content, TmfEventContent.FIELD_ID_CONTENT, event.getContent().toString())\r
+ new TmfEventField(ITmfEvent.EVENT_FIELD_TIMESTAMP, ((Long) event.getTimestamp().getValue()).toString()),\r
+ new TmfEventField(ITmfEvent.EVENT_FIELD_REFERENCE, event.getReference()),\r
+ new TmfEventField(ITmfEvent.EVENT_FIELD_TYPE, event.getType().getName()),\r
+ new TmfEventField(ITmfEvent.EVENT_FIELD_CONTENT, event.getContent().toString())\r
};\r
}\r
return fields;\r
TestSuite suite = new TestSuite("Test suite for " + TmfCorePlugin.PLUGIN_ID + ".event"); //$NON-NLS-1$);
//$JUnit-BEGIN$
suite.addTestSuite(TmfEventFieldTest.class);
- suite.addTestSuite(TmfEventContentTest.class);
suite.addTestSuite(TmfEventTypeTest.class);
suite.addTestSuite(TmfTimestampTest.class);
suite.addTestSuite(TmfTimeRangeTest.class);
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2009 Ericsson
- *
- * All rights reserved. This program and the accompanying materials are
- * made available under the terms of the Eclipse Public License v1.0 which
- * accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- * Francois Chouinard - Initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.linuxtools.tmf.core.tests.event;
-
-import junit.framework.TestCase;
-
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventContent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
-import org.eclipse.linuxtools.tmf.core.event.TmfNoSuchFieldException;
-import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
-import org.eclipse.linuxtools.tmf.stubs.event.TmfEventContentStub;
-import org.eclipse.linuxtools.tmf.stubs.event.TmfEventTypeStub;
-
-/**
- * <b><u>TmfEventContentTest</u></b>
- * <p>
- * Test suite for the TmfEventContent class.
- */
-@SuppressWarnings("nls")
-public class TmfEventContentTest extends TestCase {
-
- // ------------------------------------------------------------------------
- // Variables
- // ------------------------------------------------------------------------
-
- private final TmfTimestamp fTimestamp;
- private final String fEventSource;
- private final TmfEventType fEventType;
- private final TmfEventTypeStub fEventTypeStub;
- private final String fReference;
- private final TmfEvent fEvent;
- private final TmfEvent fEventStub;
-
- private final String fRawContent0 = "Some content";
- private final String fRawContent1 = "Some other content";
-
- private final TmfEventContent fBasicContent0;
- private final TmfEventContent fBasicContent1;
- private final TmfEventContent fBasicContent2;
- private final TmfEventContentStub fStubContent;
-
- // ------------------------------------------------------------------------
- // Housekeeping
- // ------------------------------------------------------------------------
-
- /**
- * @param name the test name
- */
- public TmfEventContentTest(String name) {
- super(name);
- fTimestamp = new TmfTimestamp();
- fEventSource = "";
- fEventType = new TmfEventTypeStub();
- fEventTypeStub = new TmfEventTypeStub();
- fReference = "";
-
- fEvent = new TmfEvent(fTimestamp, fEventSource, fEventType, fReference);
- fBasicContent0 = new TmfEventContent(fEvent, fRawContent0);
- fBasicContent1 = new TmfEventContent(fEvent, fRawContent0);
- fBasicContent2 = new TmfEventContent(fEvent, fRawContent0);
-
- fEventStub = new TmfEvent(fTimestamp, fEventSource, fEventTypeStub, fReference);
- fStubContent = new TmfEventContentStub(fEventStub, fRawContent1);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
- }
-
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
- }
-
- // ------------------------------------------------------------------------
- // Constructors
- // ------------------------------------------------------------------------
-
- public void testTmfEventContent() {
- assertSame("getLabels", fEvent, fBasicContent0.getEvent());
- assertEquals("getType", fEventType, fBasicContent0.getType());
- assertEquals("getContent", fRawContent0, fBasicContent0.getRawContent());
- }
-
- public void testTmfEventContentCopy() {
- TmfEventContent content = new TmfEventContent(fBasicContent0);
- assertSame("getLabels", fEvent, content.getEvent());
- assertEquals("getType", fEventType, content.getType());
- assertEquals("getContent", fRawContent0, content.getRawContent());
- }
-
- public void testTmfEventContentCopy2() {
- try {
- new TmfEventContent(null);
- fail("null copy");
- }
- catch (IllegalArgumentException e) {
- // Success
- }
- }
-
-// // ------------------------------------------------------------------------
-// // setEvent
-// // ------------------------------------------------------------------------
-//
-// public void testSetEvent() {
-// TmfEvent event = new TmfEvent(fTimestamp, fEventSource, fEventType, fReference);
-// TmfEventContent content1 = new TmfEventContent(event, fRawContent0);
-// event.setContent(content1);
-// TmfEventContent content2 = new TmfEventContent(null, fRawContent1);
-//
-// content2.setEvent(event);
-//
-// assertEquals("setEvent", event, content2.getEvent());
-//// assertEquals("setEvent", content2, event.getContent());
-//// assertEquals("setEvent", null, content1.getEvent());
-// }
-
- // ------------------------------------------------------------------------
- // equals
- // ------------------------------------------------------------------------
-
- public void testEqualsReflexivity() throws Exception {
- @SuppressWarnings("unused")
- Object[] fields1 = fBasicContent0.getFields();
- @SuppressWarnings("unused")
- Object[] fields2 = fStubContent.getFields();
-
- assertTrue("equals", fBasicContent0.equals(fBasicContent0));
- assertTrue("equals", fStubContent.equals(fStubContent));
-
- assertTrue("equals", !fBasicContent0.equals(fStubContent));
- assertTrue("equals", !fStubContent.equals(fBasicContent0));
- }
-
- public void testEqualsSymmetry() throws Exception {
- assertTrue("equals", fBasicContent0.equals(fBasicContent2));
- assertTrue("equals", fBasicContent2.equals(fBasicContent0));
-
- assertTrue("equals", !fBasicContent0.equals(fStubContent));
- assertTrue("equals", !fStubContent.equals(fBasicContent0));
- }
-
- public void testEqualsTransivity() throws Exception {
- assertTrue("equals", fBasicContent0.equals(fBasicContent1));
- assertTrue("equals", fBasicContent1.equals(fBasicContent2));
- assertTrue("equals", fBasicContent0.equals(fBasicContent2));
- }
-
- public void testEqualsNull() throws Exception {
- assertTrue("equals", !fBasicContent0.equals(null));
- assertTrue("equals", !fStubContent.equals(null));
- }
-
- // ------------------------------------------------------------------------
- // hashCode
- // ------------------------------------------------------------------------
-
- public void testHashCode() throws Exception {
- assertTrue("hashCode", fBasicContent0.hashCode() == fBasicContent2.hashCode());
- assertTrue("hashCode", fBasicContent0.hashCode() != fStubContent.hashCode());
- }
-
- public void testHashCode2() throws Exception {
- TmfEventContent basicContent0 = new TmfEventContent(null, fRawContent0);
- TmfEventContent basicContent1 = new TmfEventContent(fEvent, null);
- TmfEventContent basicContent2 = new TmfEventContent(null, null);
-
- assertTrue("hashCode", fBasicContent0.hashCode() == basicContent0.hashCode());
- assertTrue("hashCode", fBasicContent0.hashCode() != basicContent1.hashCode());
- assertTrue("hashCode", fBasicContent0.hashCode() != basicContent2.hashCode());
-
- assertTrue("hashCode", basicContent0.hashCode() != basicContent1.hashCode());
- assertTrue("hashCode", basicContent0.hashCode() != basicContent2.hashCode());
-
- assertTrue("hashCode", basicContent1.hashCode() == basicContent2.hashCode());
- }
-
- // ------------------------------------------------------------------------
- // toString
- // ------------------------------------------------------------------------
-
- public void testToString() {
- String expected = "TmfEventContent [fRawContent=" + fRawContent0 + ", fFields=null]";
- TmfEventContent content = new TmfEventContent(fEvent, fRawContent0);
- assertEquals("toString", expected, content.toString());
- }
-
- public void testToString2() {
- String expected = "TmfEventContent [fRawContent=" + fRawContent0 + ", fFields=null]";
- TmfEventContentStub content = new TmfEventContentStub(fEvent, fRawContent0);
- assertEquals("toString", expected, content.toString());
- }
-
- // ------------------------------------------------------------------------
- // Basic content parsing
- // ------------------------------------------------------------------------
-
- public void testGetFields() {
- TmfEventField expected = new TmfEventField(fBasicContent0, TmfEventContent.FIELD_ID_CONTENT, fRawContent0);
- Object[] fields = fBasicContent0.getFields();
- assertEquals("getFields", 1, fields.length);
- assertEquals("getFields", expected, fields[0]);
- }
-
-// public void testGetFieldFromId() {
-// Object field;
-// try {
-// field = fStubContent.getField("Content");
-// assertEquals("getField", fRawContent0, field.toString());
-// } catch (TmfNoSuchFieldException e) {
-// fail("Field not found");
-// }
-// }
-
- public void testGetFieldFromIdFailed() {
- try {
- fBasicContent0.getField("Dummy");
- fail("Found an inexisting field...");
- } catch (TmfNoSuchFieldException e) {
- // Success
- }
- }
-
- public void testGetFieldFromPos() {
- String expected = "TmfEventField [fFieldId=" +
- TmfEventContent.FIELD_ID_CONTENT + ", fValue=" + fRawContent0 + "]";
- Object field = fBasicContent0.getField(0);
- assertEquals("getField", expected, field.toString());
- }
-
- public void testGetFieldFromPosFailed() {
- Object field = fBasicContent0.getField(10);
- assertEquals("getField", null, field);
- }
-
- // ------------------------------------------------------------------------
- // Standard content parsing
- // ------------------------------------------------------------------------
-
- public void testGetFields2() {
- Object[] fields = fStubContent.getFields();
- assertEquals("getFields", 5, fields.length);
- }
-
- public void testGetFieldFromId2() {
- Object field;
- TmfEventField expected;
- try {
- field = fStubContent.getField("Field1");
- expected = new TmfEventField(fStubContent, "field1", new Integer(1));
- assertEquals("getField", expected, field);
-
- field = fStubContent.getField("Field2");
- expected = new TmfEventField(fStubContent, "field2", new Integer(-10));
- assertEquals("getField", expected, field);
-
- field = fStubContent.getField("Field3");
- expected = new TmfEventField(fStubContent, "field3", new Boolean(true));
- assertEquals("getField", expected, field);
-
- field = fStubContent.getField("Field4");
- expected = new TmfEventField(fStubContent, "field4", "some string");
- assertEquals("getField", expected, field);
-
- field = fStubContent.getField("Field5");
- expected = new TmfEventField(fStubContent, "field5", new TmfTimestamp(1, 2, 3));
- assertEquals("getField", expected, field);
-
- } catch (TmfNoSuchFieldException e) {
- fail("Field not found");
- }
- }
-
- public void testGetFieldFromPos2() {
- TmfEventContentStub content = new TmfEventContentStub(fEvent, fRawContent0);
-
- Object field;
- TmfEventField expected;
-
- field = content.getField(0);
- expected = new TmfEventField(content, "field1", new Integer(1));
- assertEquals("getField", expected, field);
-
- field = content.getField(1);
- expected = new TmfEventField(content, "field2", new Integer(-10));
- assertEquals("getField", expected, field);
-
- field = content.getField(2);
- expected = new TmfEventField(content, "field3", new Boolean(true));
- assertEquals("getField", expected, field);
-
- field = content.getField(3);
- expected = new TmfEventField(content, "field4", "some string");
- assertEquals("getField",expected, field);
-
- field = content.getField(4);
- expected = new TmfEventField(content, "field5", new TmfTimestamp(1, 2, 3));
- assertEquals("getField", expected, field);
- }
-
-}
import junit.framework.TestCase;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventContent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
-import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
-import org.eclipse.linuxtools.tmf.stubs.event.TmfEventTypeStub;
/**
* <b><u>TmfEventFieldTest</u></b>
// Variables
// ------------------------------------------------------------------------
- private final TmfEventContent fContent;
private final String fFieldId = "Field";
private final Object fValue1 = new String("Value");
private final Object fValue2 = new Integer(10);
*/
public TmfEventFieldTest(String name) {
super(name);
- TmfTimestamp fTimestamp = new TmfTimestamp();
- String fEventSource = "";
- TmfEventType fEventType = new TmfEventTypeStub();
- String fReference = "";
- TmfEvent fEvent = new TmfEvent(fTimestamp, fEventSource, fEventType, fReference);
-
- fContent = new TmfEventContent(fEvent, "Some content");
-
- fField0 = new TmfEventField(fContent, fFieldId, fValue1);
- fField1 = new TmfEventField(fContent, fFieldId, fValue1);
- fField2 = new TmfEventField(fContent, fFieldId, fValue1);
- fField3 = new TmfEventField(fContent, fFieldId, fValue2);
+ fField0 = new TmfEventField(fFieldId, fValue1, null);
+ fField1 = new TmfEventField(fFieldId, fValue1, null);
+ fField2 = new TmfEventField(fFieldId, fValue1, null);
+ fField3 = new TmfEventField(fFieldId, fValue2, null);
}
@Override
// ------------------------------------------------------------------------
public void testTmfEventField() {
- assertSame("getParent", fContent, fField0.getContent());
- assertSame("getId", fFieldId, fField0.getId());
+ assertSame("getId", fFieldId, fField0.getName());
assertSame("getValue", fValue1, fField0.getValue());
}
public void testTmfEventFieldBadArg() {
try {
- new TmfEventField(fContent, null, fValue1);
+ new TmfEventField(null, fValue1, null);
fail("null copy");
}
catch (IllegalArgumentException e) {
}
public void testTmfEventFieldCopy() {
- TmfEventField original = new TmfEventField(fContent, fFieldId, fValue1);
+ TmfEventField original = new TmfEventField(fFieldId, fValue1, null);
TmfEventField field = new TmfEventField(original);
- assertSame("getContent", fContent, field.getContent());
- assertSame("getId", fFieldId, field.getId());
+ assertSame("getId", fFieldId, field.getName());
assertSame("getValue", fValue1, field.getValue());
}
// ------------------------------------------------------------------------
private class MyField extends TmfEventField {
- public MyField(TmfEventContent parent, String id, Object value) {
- super(parent, id, value);
+ public MyField(String id, Object value) {
+ super(id, value);
}
public MyField(TmfEventField field) {
super(field);
}
@Override
- public void setValue(Object value) {
- super.setValue(value);
+ public void setValue(Object value, ITmfEventField[] subfields) {
+ super.setValue(value, subfields);
}
}
public void testSetValue() {
- TmfEventField original = new TmfEventField(fContent, fFieldId, fValue1);
+// TmfEventField original = new TmfEventField(fContent, fFieldId, fValue1);
+ TmfEventField original = new TmfEventField(fFieldId, fValue1, null);
TmfEventField field = new TmfEventField(original);
MyField myField = new MyField(field);
assertSame("getValue", fValue1, myField.getValue());
- myField.setValue(fValue2);
+ myField.setValue(fValue2, null);
assertSame("getValue", fValue2, myField.getValue());
}
public void testToString() {
String expected1 = "TmfEventField [fFieldId=" + fFieldId + ", fValue=" + fValue1.toString() + "]";
- TmfEventField field = new TmfEventField(fContent, fFieldId, fValue1);
+// TmfEventField field = new TmfEventField(fContent, fFieldId, fValue1);
+ TmfEventField field = new TmfEventField(fFieldId, fValue1, null);
assertEquals("toString", expected1, field.toString());
String expected2 = "TmfEventField [fFieldId=" + fFieldId + ", fValue=" + fValue2.toString() + "]";
- field = new TmfEventField(fContent, fFieldId, fValue2);
+// field = new TmfEventField(fContent, fFieldId, fValue2);
+ field = new TmfEventField(fFieldId, fValue2, null);
assertEquals("toString", expected2, field.toString());
}
import junit.framework.TestCase;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventContent;
+import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
private final TmfTimestamp fTimestamp1 = new TmfTimestamp(12345, (byte) 2, 5);
private final TmfTimestamp fTimestamp2 = new TmfTimestamp(12350, (byte) 2, 5);
private final String fSource = "Source";
- private final TmfEventType fType = new TmfEventType(fContext, fTypeId, fLabels);
+ private final TmfEventType fType = new TmfEventType(fContext, fTypeId, TmfEventField.makeRoot(fLabels));
private final String fReference = "Some reference";
private final TmfEvent fEvent1;
private final TmfEvent fEvent2;
- private final TmfEventContent fContent1;
- private final TmfEventContent fContent2;
+ private final TmfEventField fContent1;
+ private final TmfEventField fContent2;
// ------------------------------------------------------------------------
// Housekeeping
public TmfEventTest(String name) {
super(name);
- fEvent1 = new TmfEvent(fTimestamp1, fSource, fType, fReference);
- fContent1 = new TmfEventContent(fEvent1, "Some content");
- fEvent1.setContent(fContent1);
+ fContent1 = new TmfEventField(ITmfEventField.ROOT_ID, "Some content");
+ fEvent1 = new TmfEvent(null, fTimestamp1, fSource, fType, fContent1, fReference);
- fEvent2 = new TmfEvent(fTimestamp2, fSource, fType, fReference);
- fContent2 = new TmfEventContent(fEvent2, "Some other content");
- fEvent2.setContent(fContent2);
+ fContent2 = new TmfEventField(ITmfEventField.ROOT_ID, "Some other content");
+ fEvent2 = new TmfEvent(null, fTimestamp2, fSource, fType, fContent2, fReference);
}
@Override
import junit.framework.TestCase;
+import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
-import org.eclipse.linuxtools.tmf.core.event.TmfNoSuchFieldException;
/**
* <b><u>TmfEventTypeTest</u></b>
private final String[] fLabels1 = new String[] { fLabel0, fLabel1 };
private final String[] fLabels2 = new String[] { fLabel1, fLabel0 };
- private final TmfEventType fType0 = new TmfEventType(fContext, fTypeId, fLabels1);
- private final TmfEventType fType1 = new TmfEventType(fContext, fTypeId, fLabels1);
- private final TmfEventType fType2 = new TmfEventType(fContext, fTypeId, fLabels1);
- private final TmfEventType fType3 = new TmfEventType(fContext, fTypeId2, fLabels2);
+ private final TmfEventType fType0 = new TmfEventType(fContext, fTypeId, TmfEventField.makeRoot(fLabels1));
+ private final TmfEventType fType1 = new TmfEventType(fContext, fTypeId, TmfEventField.makeRoot(fLabels1));
+ private final TmfEventType fType2 = new TmfEventType(fContext, fTypeId, TmfEventField.makeRoot(fLabels1));
+ private final TmfEventType fType3 = new TmfEventType(fContext, fTypeId2, TmfEventField.makeRoot(fLabels2));
// ------------------------------------------------------------------------
// Housekeeping
public void testTmfEventTypeDefault() {
TmfEventType type = new TmfEventType();
- assertEquals("getTypeId", TmfEventType.DEFAULT_TYPE_ID, type.getId());
- assertEquals("getNbFields", 0, type.getNbFields());
- assertEquals("getLabels", 0, type.getFieldLabels().length);
+ assertEquals("getTypeId", TmfEventType.DEFAULT_TYPE_ID, type.getName());
+ assertNull("getLabels", type.getFieldName(0));
- try {
- assertEquals("getFieldIndex", 0, type.getFieldIndex(fLabel0));
- fail("getFieldIndex: no such field");
- assertEquals("getLabel", 0, type.getFieldLabel(0));
- fail("getFieldIndex: no such field");
- } catch (TmfNoSuchFieldException e) {
- // Success
- }
+// assertEquals("getFieldIndex", 0, type.getFieldIndex(fLabel0));
+// fail("getFieldIndex: no such field");
+ assertNull("getLabel", type.getFieldName(0));
+// fail("getFieldIndex: no such field");
}
public void testTmfEventType() {
- TmfEventType type = new TmfEventType(fContext, fTypeId, fLabels1);
+ TmfEventType type = new TmfEventType(fContext, fTypeId, TmfEventField.makeRoot(fLabels1));
String[] expected = new String[] { fLabel0, fLabel1 };
- try {
- assertEquals("getTypeId", fTypeId, type.getId());
- assertEquals("getNbFields", fLabels1.length, type.getNbFields());
- assertEquals("getFieldIndex", 0, type.getFieldIndex(fLabel0));
- assertEquals("getFieldIndex", 1, type.getFieldIndex(fLabel1));
- String[] labels = type.getFieldLabels();
+// try {
+ assertEquals("getTypeId", fTypeId, type.getName());
+// assertEquals("getFieldIndex", 0, type.getFieldIndex(fLabel0));
+// assertEquals("getFieldIndex", 1, type.getFieldIndex(fLabel1));
+ String[] labels = type.getFieldNames();
for (int i = 0; i < labels.length; i++) {
assertEquals("getLabels", expected[i], labels[i]);
}
- assertEquals("getLabel", fLabel0, type.getFieldLabel(0));
- assertEquals("getLabel", fLabel1, type.getFieldLabel(1));
- } catch (TmfNoSuchFieldException e) {
- fail("getFieldIndex: no such field");
- }
-
- try {
- assertEquals("getFieldIndex", 0, type.getFieldIndex("Dummy"));
- fail("getFieldIndex: inexistant field");
- } catch (TmfNoSuchFieldException e) {
- // Success
- }
-
- try {
- type.getFieldLabel(10);
- fail("getLabel: inexistant field");
- } catch (TmfNoSuchFieldException e) {
- // Success
- }
+ assertEquals("getLabel", fLabel0, type.getFieldName(0));
+ assertEquals("getLabel", fLabel1, type.getFieldName(1));
+// } catch (TmfNoSuchFieldException e) {
+// fail("getFieldIndex: no such field");
+// }
+
+// try {
+// assertEquals("getFieldIndex", 0, type.getFieldIndex("Dummy"));
+// fail("getFieldIndex: inexistant field");
+// } catch (TmfNoSuchFieldException e) {
+// // Success
+// }
+
+// try {
+ assertNull(type.getFieldName(10));
+// fail("getLabel: inexistant field");
+// } catch (TmfNoSuchFieldException e) {
+// // Success
+// }
}
public void testTmfEventType2() {
}
public void testTmfEventTypeCopy() {
- TmfEventType original = new TmfEventType(fContext, fTypeId, fLabels1);
+ TmfEventType original = new TmfEventType(fContext, fTypeId, TmfEventField.makeRoot(fLabels1));
TmfEventType copy = new TmfEventType(original);
String[] expected = new String[] { fLabel0, fLabel1 };
- assertEquals("getTypeId", fTypeId, copy.getId());
- assertEquals("getNbFields", fLabels1.length, copy.getNbFields());
- String[] labels = copy.getFieldLabels();
+ assertEquals("getTypeId", fTypeId, copy.getName());
+ String[] labels = copy.getFieldNames();
for (int i = 0; i < labels.length; i++) {
assertEquals("getLabels", expected[i], labels[i]);
}
public void testToString() {
String expected1 = "TmfEventType [fContext=" + TmfEventType.DEFAULT_CONTEXT_ID +
- ", fTypeId=" + TmfEventType.DEFAULT_TYPE_ID +
- ", fNbFields=0, fFieldLabels=[]]";
+ ", fTypeId=" + TmfEventType.DEFAULT_TYPE_ID + "]";
TmfEventType type1 = new TmfEventType();
assertEquals("toString", expected1, type1.toString());
- String expected2 = "TmfEventType [fContext=" + fContext + ", fTypeId=" + fTypeId +
- ", fNbFields=2, fFieldLabels=[label1, label2]]";
- TmfEventType type2 = new TmfEventType(fContext, fTypeId, fLabels1);
+ String expected2 = "TmfEventType [fContext=" + fContext + ", fTypeId=" + fTypeId + "]";
+ TmfEventType type2 = new TmfEventType(fContext, fTypeId, TmfEventField.makeRoot(fLabels1));
assertEquals("toString", expected2, type2.toString());
}
import junit.framework.TestCase;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventContent;
+import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.uml2sd.TmfAsyncSequenceDiagramEvent;
private final TmfTimestamp fTimestamp1 = new TmfTimestamp(12345, (byte) 2, 5);
private final TmfTimestamp fTimestamp2 = new TmfTimestamp(12350, (byte) 2, 5);
private final String fSource = "Source";
- private final TmfEventType fType = new TmfEventType(fContext, fTypeId, fLabels);
+ private final TmfEventType fType = new TmfEventType(fContext, fTypeId, TmfEventField.makeRoot(fLabels));
private final String fReference = "Some reference";
private final TmfEvent fEvent1;
private final TmfEvent fEvent2;
- private final TmfEventContent fContent1;
- private final TmfEventContent fContent2;
+ private final TmfEventField fContent1;
+ private final TmfEventField fContent2;
public TmfAsyncSequenceDiagramEventTest() {
- fEvent1 = new TmfEvent(fTimestamp1, fSource, fType, fReference);
- fContent1 = new TmfEventContent(fEvent1, "Some content");
- fEvent1.setContent(fContent1);
+ fContent1 = new TmfEventField(ITmfEventField.ROOT_ID, "Some content");
+ fEvent1 = new TmfEvent(null, fTimestamp1, fSource, fType, fContent1, fReference);
- fEvent2 = new TmfEvent(fTimestamp2, fSource, fType, fReference);
- fContent2 = new TmfEventContent(fEvent2, "Some other content");
- fEvent2.setContent(fContent2);
+ fContent2 = new TmfEventField(ITmfEventField.ROOT_ID, "Some other content");
+ fEvent2 = new TmfEvent(null, fTimestamp2, fSource, fType, fContent2, fReference);
}
@Override
import junit.framework.TestCase;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventContent;
+import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.uml2sd.TmfSyncSequenceDiagramEvent;
private final TmfTimestamp fTimestamp1 = new TmfTimestamp(12345, (byte) 2, 5);
private final String fSource = "Source";
- private final TmfEventType fType = new TmfEventType(fContext, fTypeId, fLabels);
+ private final TmfEventType fType = new TmfEventType(fContext, fTypeId, TmfEventField.makeRoot(fLabels));
private final String fReference = "Some reference";
private final TmfEvent fEvent1;
- private final TmfEventContent fContent1;
+ private final TmfEventField fContent1;
public TmfSyncSequenceDiagramEventTest () {
- fEvent1 = new TmfEvent(fTimestamp1, fSource, fType, fReference);
- fContent1 = new TmfEventContent(fEvent1, "Some content");
- fEvent1.setContent(fContent1);
+ fContent1 = new TmfEventField(ITmfEventField.ROOT_ID, "Some content");
+ fEvent1 = new TmfEvent(null, fTimestamp1, fSource, fType, fContent1, fReference);
}
@Override
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.linuxtools.tmf.core.component.TmfDataProvider;
-import org.eclipse.linuxtools.tmf.core.event.TmfDataItem;
+import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest;
import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest;
import org.eclipse.linuxtools.tmf.core.tests.TmfCoreTestPlugin;
* TODO: Implement me. Please.
*/
@SuppressWarnings("nls")
-public class TmfDataProviderStub extends TmfDataProvider<TmfDataItem> {
+public class TmfDataProviderStub extends TmfDataProvider<TmfEvent> {
private static final String DIRECTORY = "testfiles";
private static final String TEST_STREAM = "M-Test-10K";
private TmfTraceStub fTrace;
public TmfDataProviderStub(String path) throws IOException {
- super("TmfDataProviderStub", TmfDataItem.class);
+ super("TmfDataProviderStub", TmfEvent.class);
URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null);
try {
File test = new File(FileLocator.toFileURL(location).toURI());
// ------------------------------------------------------------------------
@Override
- public ITmfContext armRequest(ITmfDataRequest<TmfDataItem> request) {
+ public ITmfContext armRequest(ITmfDataRequest<TmfEvent> request) {
if (request instanceof ITmfEventRequest<?>) {
ITmfContext context = fTrace.seekEvent(((ITmfEventRequest<?>) request).getRange().getStartTime());
return context;
}
@Override
- public TmfDataItem getNext(ITmfContext context) {
+ public TmfEvent getNext(ITmfContext context) {
return fTrace.getNext(context);
}
@Override
- public boolean isCompleted(ITmfDataRequest<TmfDataItem> request, TmfDataItem data, int nbRead) {
+ public boolean isCompleted(ITmfDataRequest<TmfEvent> request, TmfEvent data, int nbRead) {
return false;
}
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2009 Ericsson
- *
- * All rights reserved. This program and the accompanying materials are
- * made available under the terms of the Eclipse Public License v1.0 which
- * accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- * Francois Chouinard - Initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.linuxtools.tmf.stubs.event;
-
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventContent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
-import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
-
-/**
- * <b><u>TmfEventContentStub</u></b>
- * <p>
- * TODO: Implement me. Please.
- */
-@SuppressWarnings("nls")
-public class TmfEventContentStub extends TmfEventContent {
-
- public TmfEventContentStub(TmfEvent parent, String content) {
- super(parent, content);
- }
-
- public TmfEventContentStub(TmfEventContentStub other) {
- super(other);
- }
-
- @Override
- protected void parseContent() {
- Object value1 = new Integer(1);
- Object value2 = new Integer(-10);
- Object value3 = new Boolean(true);
- Object value4 = new String("some string");
- Object value5 = new TmfTimestamp(1, (byte) 2, 3);
-
- TmfEventField field1 = new TmfEventField(this, "field1", value1);
- TmfEventField field2 = new TmfEventField(this, "field2", value2);
- TmfEventField field3 = new TmfEventField(this, "field3", value3);
- TmfEventField field4 = new TmfEventField(this, "field4", value4);
- TmfEventField field5 = new TmfEventField(this, "field5", value5);
-
- fFields = new TmfEventField[] { field1, field2, field3, field4, field5 };
- }
-
- @Override
- public TmfEventContent clone() {
- TmfEventContentStub content = new TmfEventContentStub(this);
- content.fRawContent = "Some content";
- content.fFields = null;
- return content;
- }
-
-// @Override
-// public String toString() {
-// Object[] fields = getFields();
-// StringBuilder result = new StringBuilder("[TmfEventContent(");
-// for (int i = 0; i < fields.length; i++) {
-// if (i > 0) result.append(",");
-// result.append(fields[i]);
-// }
-// result.append(")]");
-// return result.toString();
-// }
-}
/*******************************************************************************
* Copyright (c) 2009 Ericsson
*
- * All rights reserved. This program and the accompanying materials are
- * made available under the terms of the Eclipse Public License v1.0 which
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License v1.0 which
* accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
- * Contributors:
- * Francois Chouinard - Initial API and implementation
+ * Contributors: Francois Chouinard - Initial API and implementation
*******************************************************************************/
package org.eclipse.linuxtools.tmf.stubs.event;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
+import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
/**
@SuppressWarnings("nls")
public class TmfEventTypeStub extends TmfEventType {
- private static final String FIELD_1 = "Field1";
- private static final String FIELD_2 = "Field2";
- private static final String FIELD_3 = "Field3";
- private static final String FIELD_4 = "Field4";
- private static final String FIELD_5 = "Field5";
- private static final String[] FIELDS = new String[] { FIELD_1, FIELD_2, FIELD_3, FIELD_4, FIELD_5 };
+ private static final ITmfEventField FIELD_1 = new TmfEventField("Field1", null);
+ private static final ITmfEventField FIELD_2 = new TmfEventField("Field2", null);
+ private static final ITmfEventField FIELD_3 = new TmfEventField("Field3", null);
+ private static final ITmfEventField FIELD_4 = new TmfEventField("Field4", null);
+ private static final ITmfEventField FIELD_5 = new TmfEventField("Field5", null);
- public TmfEventTypeStub() {
- super("UnitTest", "TmfEventTypeStub", FIELDS);
+ private static final ITmfEventField[] FIELDS = new ITmfEventField[] {
+ FIELD_1, FIELD_2, FIELD_3, FIELD_4, FIELD_5 };
+
+ private static ITmfEventField ROOT = new TmfEventField(ITmfEventField.ROOT_ID, FIELDS);
+
+ public TmfEventTypeStub() {
+ super("UnitTest", "TmfEventTypeStub", ROOT);
}
}
package org.eclipse.linuxtools.tmf.stubs.request;
-import org.eclipse.linuxtools.tmf.core.event.TmfDataItem;
+import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
/**
* <p>
* TODO: Implement me. Please.
*/
-public class TmfDataRequestStub<T extends TmfDataItem> extends TmfDataRequest<T> {
+public class TmfDataRequestStub<T extends TmfEvent> extends TmfDataRequest<T> {
/**
* Default constructor
import java.io.RandomAccessFile;
import java.util.Vector;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventContent;
+import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.parser.ITmfEventParser;
fields.add(field);
}
String[] fieldArray = new String[i];
- fTypes[i] = new TmfEventType("UnitTest", "Type-" + i, fields.toArray(fieldArray));
+ ITmfEventField rootField = TmfEventField.makeRoot(fields.toArray(fieldArray));
+ fTypes[i] = new TmfEventType("UnitTest", "Type-" + i, rootField);
}
}
}
content += "]";
- TmfEvent event = new TmfEvent(
+ TmfEventField root = new TmfEventField(ITmfEventField.ROOT_ID, content);
+ TmfEvent event = new TmfEvent(eventStream,
new TmfTimestamp(ts, (byte) -3, 0), // millisecs
- source, fTypes[typeIndex], name);
- TmfEventContent cnt = new TmfEventContent(event, content);
- event.setContent(cnt);
+ source, fTypes[typeIndex], root, name);
+ event.setContent(root);
return event;
} catch (EOFException e) {
}
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.TmfDataItem;\r
+import org.eclipse.linuxtools.tmf.core.event.TmfEvent;\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, TmfDataItem data) {\r
+ public static void traceEvent(ITmfDataProvider<?> provider, ITmfDataRequest<?> request, TmfEvent 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.TmfDataItem;
+import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest;
/**
* <p>
* TODO: Implement me. Please.
*/
-public interface ITmfDataProvider<T extends TmfDataItem> {
+public interface ITmfDataProvider<T extends TmfEvent> {
/**
* Queues the request for processing.
import java.util.concurrent.SynchronousQueue;
import org.eclipse.linuxtools.tmf.core.Tracer;
-import org.eclipse.linuxtools.tmf.core.event.TmfDataItem;
+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.TmfCoalescedDataRequest;
import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
import org.eclipse.linuxtools.tmf.core.request.TmfRequestExecutor;
-import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest.ExecutionType;
import org.eclipse.linuxtools.tmf.core.signal.TmfEndSynchSignal;
import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
import org.eclipse.linuxtools.tmf.core.signal.TmfStartSynchSignal;
* <p>
* TODO: Add support for providing multiple data types.
*/
-public abstract class TmfDataProvider<T extends TmfDataItem> extends TmfComponent implements ITmfDataProvider<T> {
+public abstract class TmfDataProvider<T extends TmfEvent> extends TmfComponent implements ITmfDataProvider<T> {
// ------------------------------------------------------------------------
// Constants
import java.util.List;
import java.util.Map;
-import org.eclipse.linuxtools.tmf.core.event.TmfDataItem;
+import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
/**
* <b><u>TmfProviderManager.java</u></b>
// Keeps track of the providers for each event type
// ------------------------------------------------------------------------
- private static Map<Class<? extends TmfDataItem>, List<TmfDataProvider<? extends TmfDataItem>>> fProviders =
- new HashMap<Class<? extends TmfDataItem>, List<TmfDataProvider<? extends TmfDataItem>>>();
+ private static Map<Class<? extends TmfEvent>, List<TmfDataProvider<? extends TmfEvent>>> fProviders =
+ new HashMap<Class<? extends TmfEvent>, List<TmfDataProvider<? extends TmfEvent>>>();
/**
* Registers [provider] as a provider of [eventType]
* @param eventType
* @param provider
*/
- public static <T extends TmfDataItem> void register(Class<T> eventType, TmfDataProvider<? extends TmfDataItem> provider) {
+ public static <T extends TmfEvent> void register(Class<T> eventType, TmfDataProvider<? extends TmfEvent> provider) {
if (fProviders.get(eventType) == null)
- fProviders.put(eventType, new ArrayList<TmfDataProvider<? extends TmfDataItem>>());
+ fProviders.put(eventType, new ArrayList<TmfDataProvider<? extends TmfEvent>>());
fProviders.get(eventType).add(provider);
}
* @param dataClass
* @param provider
*/
- public static <T extends TmfDataItem> void deregister(Class<T> dataClass, TmfDataProvider<? extends TmfDataItem> provider) {
- List<TmfDataProvider<? extends TmfDataItem>> list = fProviders.get(dataClass);
+ public static <T extends TmfEvent> void deregister(Class<T> dataClass, TmfDataProvider<? extends TmfEvent> provider) {
+ List<TmfDataProvider<? extends TmfEvent>> list = fProviders.get(dataClass);
if (list != null) {
list.remove(provider);
if (list.size() == 0)
* @return
*/
@SuppressWarnings("unchecked")
- public static TmfDataProvider<? extends TmfDataItem>[] getProviders(Class<? extends TmfDataItem> dataClass) {
- List<TmfDataProvider<? extends TmfDataItem>> list = fProviders.get(dataClass);
+ public static TmfDataProvider<? extends TmfEvent>[] getProviders(Class<? extends TmfEvent> dataClass) {
+ List<TmfDataProvider<? extends TmfEvent>> list = fProviders.get(dataClass);
if (list == null)
- list = new ArrayList<TmfDataProvider<? extends TmfDataItem>>();
- TmfDataProvider<? extends TmfDataItem>[] result = new TmfDataProvider[list.size()];
+ list = new ArrayList<TmfDataProvider<? extends TmfEvent>>();
+ TmfDataProvider<? extends TmfEvent>[] result = new TmfDataProvider[list.size()];
return list.toArray(result);
}
* @return
*/
@SuppressWarnings("unchecked")
- public static TmfDataProvider<? extends TmfDataItem>[] getProviders(Class<? extends TmfDataItem> dataClass, Class<? extends TmfDataProvider<? extends TmfDataItem>> providerClass) {
+ public static TmfDataProvider<? extends TmfEvent>[] getProviders(Class<? extends TmfEvent> dataClass, Class<? extends TmfDataProvider<? extends TmfEvent>> providerClass) {
if (providerClass == null) {
return getProviders(dataClass);
}
- TmfDataProvider<? extends TmfDataItem>[] list = getProviders(dataClass);
- List<TmfDataProvider<? extends TmfDataItem>> result = new ArrayList<TmfDataProvider<? extends TmfDataItem>>();
+ TmfDataProvider<? extends TmfEvent>[] list = getProviders(dataClass);
+ List<TmfDataProvider<? extends TmfEvent>> result = new ArrayList<TmfDataProvider<? extends TmfEvent>>();
if (list != null) {
- for (TmfDataProvider<? extends TmfDataItem> provider : list) {
+ for (TmfDataProvider<? extends TmfEvent> provider : list) {
if (provider.getClass() == providerClass) {
result.add(provider);
}
}
}
- TmfDataProvider<? extends TmfDataItem>[] array = new TmfDataProvider[result.size()];
+ TmfDataProvider<? extends TmfEvent>[] array = new TmfDataProvider[result.size()];
return result.toArray(array);
}
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2012 Ericsson
- *
- * All rights reserved. This program and the accompanying materials are
- * made available under the terms of the Eclipse Public License v1.0 which
- * accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- * Francois Chouinard - Initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.linuxtools.tmf.core.event;
-
-import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
-
-/**
- * <b><u>ITmfDataItem</u></b>
- * <p>
- * The basic event structure in the TMF. In its canonical form, a data item has:
- * <ul>
- * <li> a parent trace
- * <li> a rank (order within the trace)
- * <li> a source (reporting component)
- * <li> a type
- * <li> a content
- * </ul>
- * For convenience, a free-form reference field is also provided. It could be
- * used as e.g. a location marker (filename:lineno) to indicate where the event
- * was generated.
- */
-public interface ITmfDataItem extends Cloneable {
-
- /**
- * @return the trace that 'owns' the event
- */
- public ITmfTrace<?> getTrace();
-
- /**
- * @return the event rank within the parent trace
- */
- public long getRank();
-
- /**
- * @return the event source
- */
- public String getSource();
-
- /**
- * @return the event type
- */
- public ITmfEventType getType();
-
- /**
- * @return the event content
- */
- public ITmfEventContent getContent();
-
- /**
- * @return the event reference
- */
- public String getReference();
-
- /**
- * @return a clone of the data item
- */
- public ITmfDataItem clone();
-
-}
package org.eclipse.linuxtools.tmf.core.event;
+import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
+
/**
* <b><u>ITmfEvent</u></b>
* <p>
- * The ITmfEvent is essentially an ITmfDataEvent with a timestamp.
-*/
-public interface ITmfEvent extends ITmfDataItem, Cloneable {
+ * The basic event structure in the TMF. In its canonical form, a data item has:
+ * <ul>
+ * <li> a parent trace
+ * <li> a rank (order within the trace)
+ * <li> a timestamp
+ * <li> a source (reporting component)
+ * <li> a type
+ * <li> a content (payload)
+ * </ul>
+ * For convenience, a free-form reference field is also provided. It could be
+ * used as e.g. a location marker (filename:lineno) to indicate where the event
+ * was generated.
+ */
+public interface ITmfEvent extends Cloneable {
+
+ /**
+ * Pre-defined event attributes
+ */
+ public String EVENT_FIELD_TIMESTAMP = ":timestamp:"; //$NON-NLS-1$
+ public String EVENT_FIELD_SOURCE = ":source:"; //$NON-NLS-1$
+ public String EVENT_FIELD_TYPE = ":type:"; //$NON-NLS-1$
+ public String EVENT_FIELD_CONTENT = ":content:"; //$NON-NLS-1$
+ public String EVENT_FIELD_REFERENCE = ":reference:"; //$NON-NLS-1$
+
+ /**
+ * @return the trace that 'owns' the event
+ */
+ public ITmfTrace<?> getTrace();
+
+ /**
+ * @return the event rank within the parent trace
+ */
+ public long getRank();
/**
* @return the event timestamp
*/
public ITmfTimestamp getTimestamp();
+ /**
+ * @return the event source
+ */
+ public String getSource();
+
+ /**
+ * @return the event type
+ */
+ public ITmfEventType getType();
+
+ /**
+ * @return the event content
+ */
+ public ITmfEventField getContent();
+
+ /**
+ * @return the event reference
+ */
+ public String getReference();
+
+ /**
+ * @return a clone of the data item
+ */
+ public ITmfEvent clone();
+
}
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2012 Ericsson
- *
- * All rights reserved. This program and the accompanying materials are
- * made available under the terms of the Eclipse Public License v1.0 which
- * accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- * Francois Chouinard - Initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.linuxtools.tmf.core.event;
-
-/**
- * <b><u>ITmfEventContent</u></b>
- * <p>
- */
-public interface ITmfEventContent extends Cloneable {
-
- /**
- * @return the raw event content
- */
- public Object getRawContent();
-
- /**
- * @return the formatted event content (string'ified)
- */
- public String getFmtContent();
-
- /**
- * @return the event type
- */
- public ITmfEventType getType();
-
- /**
- * @return the list of event fields
- */
- public ITmfEventField[] getFields();
-
- /**
- * @param index the field index
- * @return the corresponding field
- */
- public ITmfEventField getField(int index) throws TmfNoSuchFieldException;
-
- /**
- * @param name the field name
- * @return the corresponding field
- */
- public ITmfEventField getField(String name) throws TmfNoSuchFieldException;
-
- /**
- * @return a clone of the event content
- */
- public ITmfEventContent clone();
-}
/**
* <b><u>ITmfEventField</u></b>
* <p>
+ * The TMF event payload structure. Each field can be either a terminal or
+ * further decomposed into subfields.
*/
public interface ITmfEventField extends Cloneable {
+ /**
+ * The root field id (the main container)
+ */
+ public static final String ROOT_ID = ":root:"; //$NON-NLS-1$
+
/**
* @return the field ID
*/
- public String getId();
+ public String getName();
/**
* @return the field value
public Object getValue();
/**
- * @return the list of subfields (if any)
+ * @return the list of subfield names (empty array if none)
+ */
+ public String[] getFieldNames();
+
+ /**
+ * @return the nth field name (null if absent or inexistent)
+ */
+ public String getFieldName(int index);
+
+ /**
+ * @return the list of subfields (empty array if none)
+ */
+ public ITmfEventField[] getFields();
+
+ /**
+ * @return a specific subfield by name (null if absent or inexistent)
+ */
+ public ITmfEventField getField(String name);
+
+ /**
+ * @return a specific subfield by index (null if absent or inexistent)
*/
- public ITmfEventField[] getSubFields();
+ public ITmfEventField getField(int index);
/**
* @return a clone of the event type
/**
* <b><u>ITmfEventType</u></b>
* <p>
+ * The TMF event event type. It contains a reference to the full field structure
+ * for that event type.
+ * <p>
+ * Types are unique within their context space.
*/
public interface ITmfEventType extends Cloneable {
+ /**
+ * The default event type content
+ */
+ public static final String DEFAULT_CONTEXT_ID = "TmfContext"; //$NON-NLS-1$
+
+ /**
+ * The default event type name
+ */
+ public static final String DEFAULT_TYPE_ID = "TmfType"; //$NON-NLS-1$
+
/**
* @return the event type context
*/
/**
* @return the event type ID
*/
- public String getId();
+ public String getName();
/**
- * @return the number of fields
+ * @return the event type root field
*/
- public int getNbFields();
+ public ITmfEventField getRootField();
/**
- * @return the event field labels
+ * @return the event field names (labels)
*/
- public String[] getFieldLabels();
+ public String[] getFieldNames();
/**
* @param index the event field index
* @return the corresponding event field label
*/
- public String getFieldLabel(int index) throws TmfNoSuchFieldException;
-
- /**
- * @param fieldId the event field ID
- * @return the corresponding event field index
- */
- public int getFieldIndex(String fieldId) throws TmfNoSuchFieldException;
+ public String getFieldName(int index);
/**
* @return a clone of the event content
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2009, 2012 Ericsson
- *
- * All rights reserved. This program and the accompanying materials are
- * made available under the terms of the Eclipse Public License v1.0 which
- * accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- * Francois Chouinard - Initial API and implementation
- * Francois Chouinard - Updated as per TMF Event Model 1.0
- *******************************************************************************/
-
-package org.eclipse.linuxtools.tmf.core.event;
-
-import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
-
-/**
- * <b><u>TmfDataItem</u></b>
- * <p>
- * A basic implementation of ITmfDataItem.
- *
- * Notice that for performance reasons TmfDataEvent is NOT immutable. If a copy
- * of an event is needed, use the copy constructor (shallow copy) or the clone()
- * method (deep copy).
- */
-public class TmfDataItem implements ITmfDataItem {
-
- // ------------------------------------------------------------------------
- // Attributes
- // ------------------------------------------------------------------------
-
- protected ITmfTrace<? extends TmfDataItem> fTrace;
- protected long fRank;
- protected String fSource;
- protected ITmfEventType fType;
- protected ITmfEventContent fContent;
- protected String fReference;
-
- // ------------------------------------------------------------------------
- // Constructors
- // ------------------------------------------------------------------------
-
- /**
- * Default constructor
- */
- public TmfDataItem() {
- }
-
- /**
- * Full constructor
- *
- * @param trace the parent trace
- * @param rank the vent rank (in the trace)
- * @param source the event source
- * @param type the event type
- * @param reference the event reference
- */
- public TmfDataItem(ITmfTrace<? extends TmfDataItem> trace, long rank,
- String source, TmfEventType type, TmfEventContent content,
- String reference)
- {
- fTrace = trace;
- fRank = rank;
- fSource = source;
- fType = type;
- fContent = content;
- fReference = reference;
- }
-
- /**
- * Copy constructor
- *
- * @param event the original event
- */
- public TmfDataItem(TmfDataItem event) {
- if (event == null)
- throw new IllegalArgumentException();
- fTrace = event.fTrace;
- fRank = event.fRank;
- fSource = event.fSource;
- fType = event.fType;
- fContent = event.fContent;
- fReference = event.fReference;
- }
-
- // ------------------------------------------------------------------------
- // ITmfDataItem
- // ------------------------------------------------------------------------
-
- /**
- * @return the parent trace
- */
- public ITmfTrace<? extends TmfDataItem> getTrace() {
- return fTrace;
- }
-
- /**
- * @return the event rank
- */
- public long getRank() {
- return fRank;
- }
-
- /**
- * @return the event source
- */
- public String getSource() {
- return fSource;
- }
-
- /**
- * @return the event type
- */
- public ITmfEventType getType() {
- return fType;
- }
-
- /**
- * @return the event content
- */
- public ITmfEventContent getContent() {
- return fContent;
- }
-
- /**
- * @return the event reference
- */
- public String getReference() {
- return fReference;
- }
-
- // ------------------------------------------------------------------------
- // Convenience setters
- // ------------------------------------------------------------------------
-
- /**
- * @param source the new event source
- */
- public void setSource(String source) {
- fSource = source;
- }
-
- /**
- * @param type the new event type
- */
- public void setType(TmfEventType type) {
- fType = type;
- }
-
- /**
- * @param content the event new content
- */
- public void setContent(TmfEventContent content) {
- fContent = content;
- }
-
- /**
- * @param reference the new event reference
- */
- public void setReference(String reference) {
- fReference = reference;
- }
-
- // ------------------------------------------------------------------------
- // Cloneable
- // ------------------------------------------------------------------------
-
- @Override
- public TmfDataItem clone() {
- TmfDataItem clone = null;
- try {
- clone = (TmfDataItem) super.clone();
- clone.fTrace = fTrace;
- clone.fRank = fRank;
- clone.fSource = fSource;
- clone.fType = fType != null ? fType.clone() : null;
- clone.fContent = fContent != null ? fContent.clone() : null;
- clone.fReference = fReference;
- } catch (CloneNotSupportedException e) {
- }
- return clone;
- }
-
- // ------------------------------------------------------------------------
- // Object
- // ------------------------------------------------------------------------
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + ((fContent == null) ? 0 : fContent.hashCode());
- result = prime * result + (int) (fRank ^ (fRank >>> 32));
- result = prime * result + ((fReference == null) ? 0 : fReference.hashCode());
- result = prime * result + ((fSource == null) ? 0 : fSource.hashCode());
- result = prime * result + ((fTrace == null) ? 0 : fTrace.hashCode());
- result = prime * result + ((fType == null) ? 0 : fType.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- TmfDataItem other = (TmfDataItem) obj;
- if (fContent == null) {
- if (other.fContent != null)
- return false;
- } else if (!fContent.equals(other.fContent))
- return false;
- if (fRank != other.fRank)
- return false;
- if (fReference == null) {
- if (other.fReference != null)
- return false;
- } else if (!fReference.equals(other.fReference))
- return false;
- if (fSource == null) {
- if (other.fSource != null)
- return false;
- } else if (!fSource.equals(other.fSource))
- return false;
- if (fTrace == null) {
- if (other.fTrace != null)
- return false;
- } else if (!fTrace.equals(other.fTrace))
- return false;
- if (fType == null) {
- if (other.fType != null)
- return false;
- } else if (!fType.equals(other.fType))
- return false;
- return true;
- }
-
- @Override
- @SuppressWarnings("nls")
- public String toString() {
- return "TmfDataEvent [fTrace=" + fTrace + ", fRank=" + fRank
- + ", fSource=" + fSource + ", fType=" + fType + ", fContent="
- + fContent + ", fReference=" + fReference + "]";
- }
-
-}
/**
* <b><u>TmfEvent</u></b>
* <p>
- * The basic event structure in the TMF. In its canonical form, an event has:
- * <ul>
- * <li>a normalized timestamp
- * <li>a source (reporter)
- * <li>a type
- * <li>a content
- * </ul>
- * For convenience, a free-form reference field is also provided. It could be
- * used as e.g. a location marker in the event stream to distinguish between
- * otherwise identical events.
+ * A basic implementation of ITmfEvent.
*
- * Notice that for performance reasons TmfEvent is NOT immutable. If a copy of
+ * Note that for performance reasons TmfEvent is NOT immutable. If a copy of
* the event is needed, use the copy constructor.
*/
-public class TmfEvent extends TmfDataItem implements ITmfEvent {
+public class TmfEvent implements ITmfEvent {
// ------------------------------------------------------------------------
// Attributes
// ------------------------------------------------------------------------
+ protected ITmfTrace<? extends TmfEvent> fTrace;
+ protected long fRank;
protected ITmfTimestamp fTimestamp;
+ protected String fSource;
+ protected ITmfEventType fType;
+ protected ITmfEventField fContent;
+ protected String fReference;
// ------------------------------------------------------------------------
// Constructors
* Full constructor
*
* @param trace the parent trace
- * @param rank the vent rank (in the trace)
+ * @param rank the event rank (in the trace)
* @param timestamp the event timestamp
* @param source the event source
* @param type the event type
+ * @param type the event content (payload)
* @param reference the event reference
*/
- public TmfEvent(ITmfTrace<?> trace, long rank, ITmfTimestamp timestamp, String source,
- TmfEventType type, String reference)
+ public TmfEvent(ITmfTrace<? extends TmfEvent> trace, long rank, ITmfTimestamp timestamp, String source,
+ TmfEventType type, ITmfEventField content, String reference)
{
- super(trace, rank, source, type, null, reference);
+ fTrace = trace;
+ fRank = rank;
fTimestamp = timestamp;
+ fSource = source;
+ fType = type;
+ fContent = content;
+ fReference = reference;
}
/**
* Constructor - no rank
*/
- public TmfEvent(ITmfTrace<?> parentTrace, ITmfTimestamp timestamp, String source,
- TmfEventType type, String reference)
+ public TmfEvent(ITmfTrace<? extends TmfEvent> trace, ITmfTimestamp timestamp, String source,
+ TmfEventType type, ITmfEventField content, String reference)
{
- this(parentTrace, -1, timestamp, source, type, reference);
+ this(trace, -1, timestamp, source, type, content, reference);
}
/**
- * Constructor - no trace, no rank
+ * Constructor - no rank, no content
*/
- public TmfEvent(ITmfTimestamp timestamp, String source, TmfEventType type, String reference) {
- this(null, -1, timestamp, source, type, reference);
+ public TmfEvent(ITmfTrace<? extends TmfEvent> trace, ITmfTimestamp timestamp, String source,
+ TmfEventType type, String reference)
+ {
+ this(trace, -1, timestamp, source, type, null, reference);
+ }
+
+ /**
+ * Constructor - no rank, no content, no trace
+ */
+ public TmfEvent(TmfTimestamp timestamp, String source, TmfEventType type, String reference)
+ {
+ this(null, -1, timestamp, source, type, null, reference);
}
/**
* @param event the original event
*/
public TmfEvent(TmfEvent event) {
- super(event);
- fTimestamp = event.fTimestamp != null ? event.fTimestamp.clone() : null;
+ 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;
}
// ------------------------------------------------------------------------
// ITmfEvent
// ------------------------------------------------------------------------
- /**
- * @return the effective event timestamp
- */
+ public ITmfTrace<? extends TmfEvent> getTrace() {
+ return fTrace;
+ }
+
+ public long getRank() {
+ return fRank;
+ }
+
public ITmfTimestamp getTimestamp() {
return fTimestamp;
}
+ public String getSource() {
+ return fSource;
+ }
+
+ public ITmfEventType getType() {
+ return fType;
+ }
+
+ public ITmfEventField getContent() {
+ return fContent;
+ }
+
+ public String getReference() {
+ return fReference;
+ }
+
+ // ------------------------------------------------------------------------
+ // Convenience setters
+ // ------------------------------------------------------------------------
+
+ /**
+ * @param source the new event source
+ */
+ public void setSource(String source) {
+ fSource = source;
+ }
+
+ /**
+ * @param timestamp the new event timestamp
+ */
+ public void setTimestamp(ITmfTimestamp timestamp) {
+ fTimestamp = timestamp;
+ }
+
+ /**
+ * @param type the new event type
+ */
+ public void setType(TmfEventType type) {
+ fType = type;
+ }
+
+ /**
+ * @param content the event new content
+ */
+ public void setContent(ITmfEventField content) {
+ fContent = content;
+ }
+
+ /**
+ * @param reference the new event reference
+ */
+ public void setReference(String reference) {
+ fReference = reference;
+ }
+
// ------------------------------------------------------------------------
// Cloneable
// ------------------------------------------------------------------------
@Override
public TmfEvent clone() {
TmfEvent clone = null;
- clone = (TmfEvent) super.clone();
- clone.fTimestamp = fTimestamp != null ? fTimestamp.clone() : null;
+ try {
+ clone = (TmfEvent) super.clone();
+ clone.fTrace = fTrace;
+ clone.fRank = fRank;
+ clone.fTimestamp = fTimestamp != null ? fTimestamp.clone() : null;
+ clone.fSource = fSource;
+ clone.fType = fType != null ? fType.clone() : null;
+ clone.fContent = fContent != null ? fContent.clone() : null;
+ clone.fReference = fReference;
+ } catch (CloneNotSupportedException e) {
+ }
return clone;
}
@Override
public int hashCode() {
final int prime = 31;
- int result = super.hashCode();
+ int result = 1;
+ result = prime * result + ((fTrace == null) ? 0 : fTrace.hashCode());
+ result = prime * result + (int) (fRank ^ (fRank >>> 32));
result = prime * result + ((fTimestamp == null) ? 0 : fTimestamp.hashCode());
+ result = prime * result + ((fSource == null) ? 0 : fSource.hashCode());
+ result = prime * result + ((fType == null) ? 0 : fType.hashCode());
+ result = prime * result + ((fContent == null) ? 0 : fContent.hashCode());
+ result = prime * result + ((fReference == null) ? 0 : fReference.hashCode());
return result;
}
public boolean equals(Object obj) {
if (this == obj)
return true;
- if (!super.equals(obj))
+ if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
TmfEvent other = (TmfEvent) obj;
+ if (fTrace == null) {
+ if (other.fTrace != null)
+ return false;
+ } else if (!fTrace.equals(other.fTrace))
+ return false;
+ if (fRank != other.fRank)
+ return false;
if (fTimestamp == null) {
if (other.fTimestamp != null)
return false;
} else if (!fTimestamp.equals(other.fTimestamp))
return false;
+ if (fSource == null) {
+ if (other.fSource != null)
+ return false;
+ } else if (!fSource.equals(other.fSource))
+ return false;
+ if (fType == null) {
+ if (other.fType != null)
+ return false;
+ } else if (!fType.equals(other.fType))
+ return false;
+ if (fContent == null) {
+ if (other.fContent != null)
+ return false;
+ } else if (!fContent.equals(other.fContent))
+ return false;
+ if (fReference == null) {
+ if (other.fReference != null)
+ return false;
+ } else if (!fReference.equals(other.fReference))
+ return false;
return true;
}
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2009, 2012 Ericsson
- *
- * All rights reserved. This program and the accompanying materials are
- * made available under the terms of the Eclipse Public License v1.0 which
- * accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- * Francois Chouinard - Initial API and implementation
- * Francois Chouinard - Updated as per TMF Event Model 1.0
- *******************************************************************************/
-
-package org.eclipse.linuxtools.tmf.core.event;
-
-import java.util.Arrays;
-
-/**
- * <b><u>TmfEventContent</u></b>
- * <p>
- * A basic implementation of ITmfEventContent where the raw content is a String.
- */
-public class TmfEventContent implements ITmfEventContent {
-
- // ------------------------------------------------------------------------
- // Constants
- // ------------------------------------------------------------------------
-
- // Default field IDs
- public static final String FIELD_ID_TIMESTAMP = ":timestamp:"; //$NON-NLS-1$
- public static final String FIELD_ID_SOURCE = ":source:"; //$NON-NLS-1$
- public static final String FIELD_ID_TYPE = ":type:"; //$NON-NLS-1$
- public static final String FIELD_ID_REFERENCE = ":reference:"; //$NON-NLS-1$
- public static final String FIELD_ID_CONTENT = ":content:"; //$NON-NLS-1$
-
- // ------------------------------------------------------------------------
- // Attributes
- // ------------------------------------------------------------------------
-
- protected TmfEvent fParentEvent;
- protected String fRawContent;
- protected TmfEventField[] fFields;
-
- // ------------------------------------------------------------------------
- // Constructors
- // ------------------------------------------------------------------------
-
- /**
- * Default constructor
- */
- @SuppressWarnings("unused")
- private TmfEventContent() {
- throw new AssertionError();
- }
-
- /**
- * Full constructor
- *
- * @param parent the parent event (owner)
- * @param content the raw content as a byte[]
- */
- public TmfEventContent(TmfEvent parent, String content) {
- fParentEvent = parent;
- fRawContent = content;
- }
-
- /**
- * Copy constructor
- *
- * @param content the original event content
- */
- public TmfEventContent(TmfEventContent content) {
- if (content == null)
- throw new IllegalArgumentException();
- fParentEvent = content.fParentEvent;
- fRawContent = content.fRawContent;
- fFields = content.fFields;
- }
-
- // ------------------------------------------------------------------------
- // Accessors
- // ------------------------------------------------------------------------
-
- /**
- * @return the parent (containing) event
- */
- public TmfEvent getEvent() {
- return fParentEvent;
- }
-
- /**
- * @return the event type
- */
- public ITmfEventType getType() {
- return fParentEvent.getType();
- }
-
- /**
- * @return the raw content
- */
- public Object getRawContent() {
- return fRawContent;
- }
-
- /**
- * @return the serialized content
- */
- public String getFmtContent() {
- return fRawContent;
- }
-
- /**
- * Returns the list of fields in the same order as TmfEventType.getLabels()
- *
- * @return the ordered set of fields (optional fields might be null)
- */
- public ITmfEventField[] getFields() {
- if (fFields == null) {
- parseContent();
- }
- return fFields;
- }
-
- /**
- * @param id the field id
- * @return the corresponding field
- * @throws TmfNoSuchFieldException
- */
- public ITmfEventField getField(String id) throws TmfNoSuchFieldException {
- if (fFields == null) {
- parseContent();
- }
- try {
- return fFields[getType().getFieldIndex(id)];
- } catch (TmfNoSuchFieldException e) {
- // Required for filtering from default TmfEventsTable columns
- if (id.equals(FIELD_ID_CONTENT)) {
- return new TmfEventField(this, FIELD_ID_CONTENT, toString());
- } else if (id.equals(FIELD_ID_TIMESTAMP)) {
- return new TmfEventField(this, FIELD_ID_TIMESTAMP, fParentEvent.getTimestamp().toString());
- } else if (id.equals(FIELD_ID_SOURCE)) {
- return new TmfEventField(this, FIELD_ID_SOURCE, fParentEvent.getSource());
- } else if (id.equals(FIELD_ID_TYPE)) {
- return new TmfEventField(this, FIELD_ID_TYPE, fParentEvent.getType().getId());
- } else if (id.equals(FIELD_ID_REFERENCE)) {
- return new TmfEventField(this, FIELD_ID_REFERENCE, fParentEvent.getReference());
- }
- throw e;
- }
- }
-
- /**
- * @param n the field index as per TmfEventType.getLabels()
- * @return the corresponding field (null if non-existing)
- */
- public ITmfEventField getField(int n) {
- if (fFields == null) {
- parseContent();
- }
- if (n >= 0 && n < fFields.length)
- return fFields[n];
-
- return null;
- }
-
- // ------------------------------------------------------------------------
- // Operations
- // ------------------------------------------------------------------------
-
- /**
- * Parse the content into fields. By default, a single field (the raw
- * content) is returned.
- *
- * Should be overridden.
- */
- protected void parseContent() {
- fFields = new TmfEventField[1];
- fFields[0] = new TmfEventField(this, FIELD_ID_CONTENT, fRawContent);
- }
-
- // ------------------------------------------------------------------------
- // Cloneable
- // ------------------------------------------------------------------------
-
- @Override
- public ITmfEventContent clone() {
- TmfEventContent clone = null;
- try {
- clone = (TmfEventContent) super.clone();
- clone.fParentEvent = fParentEvent;
- clone.fRawContent = fRawContent;
- clone.fFields = fFields;
- }
- catch (CloneNotSupportedException e) {
- e.printStackTrace();
- }
- return clone;
- }
-
- // ------------------------------------------------------------------------
- // Object
- // ------------------------------------------------------------------------
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + Arrays.hashCode(fFields);
- result = prime * result + ((fRawContent == null) ? 0 : fRawContent.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- TmfEventContent other = (TmfEventContent) obj;
- if (!Arrays.equals(fFields, other.fFields))
- return false;
- if (fRawContent == null) {
- if (other.fRawContent != null)
- return false;
- } else if (!fRawContent.equals(other.fRawContent))
- return false;
- return true;
- }
-
- @Override
- @SuppressWarnings("nls")
- public String toString() {
- return "TmfEventContent [fRawContent=" + fRawContent + ", fFields=" + Arrays.toString(fFields) + "]";
- }
-
-}
package org.eclipse.linuxtools.tmf.core.event;
+import java.util.HashMap;
+import java.util.Map;
+
/**
* <b><u>TmfEventField</u></b>
* <p>
- * A basic implementation of ITmfEventField with no subfields.
+ * A basic implementation of ITmfEventField.
*/
public class TmfEventField implements ITmfEventField {
// Attributes
// ------------------------------------------------------------------------
- protected ITmfEventContent fEventContent;
- protected String fFieldId;
- protected Object fValue;
- protected ITmfEventField[] fSubFields;
+ private String fName;
+ private Object fValue;
+ private ITmfEventField[] fFields;
+ private String[] fFieldNames;
+ private Map<String, ITmfEventField> fNameMapping;
+
// ------------------------------------------------------------------------
// Constructors
// ------------------------------------------------------------------------
throw new AssertionError();
}
+ /**
+ * Constructor for a terminal field (i.e. no subfields)
+ *
+ * @param name the event field id
+ * @param value the event field value
+ */
+ public TmfEventField(String name, Object value) {
+ this(name, value, new ITmfEventField[0]);
+ }
+
+ /**
+ * Constructor for a non-valued field (for structural purposes)
+ *
+ * @param name the event field id
+ * @param subfields the list of subfields
+ */
+ public TmfEventField(String name, ITmfEventField[] fields) {
+ this(name, null, fields);
+ }
+
/**
* Full constructor
*
- * @param content the event content (field container)
- * @param id the event field id
+ * @param name the event field id
* @param value the event field value
+ * @param subfields the list of subfields
*/
- public TmfEventField(ITmfEventContent content, String id, Object value) {
- if (id == null) {
+ public TmfEventField(String name, Object value, ITmfEventField[] fields) {
+ if (name == null) {
throw new IllegalArgumentException();
}
- fEventContent = content;
- fFieldId = id;
+ fName = name;
fValue = value;
- fSubFields = null;
+ fFields = fields;
+ populateStructs();
}
/**
public TmfEventField(TmfEventField field) {
if (field == null)
throw new IllegalArgumentException();
- fEventContent = field.fEventContent;
- fFieldId = field.fFieldId;
+ fName = field.fName;
fValue = field.fValue;
- fSubFields = field.fSubFields;
+ fFields = field.fFields;
+ fFieldNames = field.fFieldNames;
}
// ------------------------------------------------------------------------
// ITmfEventField
// ------------------------------------------------------------------------
- public ITmfEventContent getContent() {
- return fEventContent;
- }
-
- public String getId() {
- return fFieldId;
+ public String getName() {
+ return fName;
}
public Object getValue() {
return fValue;
}
- public ITmfEventField[] getSubFields() {
- return fSubFields;
+ public String[] getFieldNames() {
+ return fFieldNames;
+ }
+
+ public String getFieldName(int index) {
+ ITmfEventField field = getField(index);
+ if (field != null) {
+ return field.getName();
+ }
+ return null;
+ }
+
+ public ITmfEventField[] getFields() {
+ return fFields;
+ }
+
+ public ITmfEventField getField(String name) {
+ return fNameMapping.get(name);
+ }
+
+ public ITmfEventField getField(int index) {
+ if (index >= 0 && index < fFields.length)
+ return fFields[index];
+ return null;
}
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
/**
- * @param value new field value
+ * @param value new field raw value
+ * @param fields the corresponding fields
*/
- protected void setValue(Object value) {
+ protected void setValue(Object value, ITmfEventField[] fields) {
fValue = value;
+ fFields = fields;
+ populateStructs();
+ }
+
+ // ------------------------------------------------------------------------
+ // Operations
+ // ------------------------------------------------------------------------
+
+ /**
+ * Create a root field from a list of labels.
+ *
+ * @param labels the list of labels
+ * @return the (flat) root list
+ */
+ public final static ITmfEventField makeRoot(String[] labels) {
+ ITmfEventField[] fields = new ITmfEventField[labels.length];
+ for (int i = 0; i < labels.length; i++) {
+ fields[i] = new TmfEventField(labels[i], null);
+ }
+ ITmfEventField rootField = new TmfEventField(ITmfEventField.ROOT_ID, fields);
+ return rootField;
+ }
+
+ /*
+ * Populate the subfield names and the name map
+ */
+ private void populateStructs() {
+ int nbFields = (fFields != null) ? fFields.length : 0;
+ fFieldNames = new String[nbFields];
+ fNameMapping = new HashMap<String, ITmfEventField>();
+ for (int i = 0; i < nbFields; i++) {
+ String name = fFields[i].getName();
+ fFieldNames[i] = name;
+ fNameMapping.put(name, fFields[i]);
+ }
}
// ------------------------------------------------------------------------
TmfEventField clone = null;
try {
clone = (TmfEventField) super.clone();
- clone.fEventContent = fEventContent;
- clone.fFieldId = fFieldId;
+ clone.fName = fName;
clone.fValue = fValue;
- clone.fSubFields = (fSubFields != null) ? fSubFields.clone() : null;
+ clone.fFields = (fFields != null) ? fFields.clone() : null;
+ clone.populateStructs();
} catch (CloneNotSupportedException e) {
}
return clone;
public int hashCode() {
final int prime = 31;
int result = 1;
- result = prime * result + ((fEventContent == null) ? 0 : fEventContent.hashCode());
- result = prime * result + ((fFieldId == null) ? 0 : fFieldId.hashCode());
+ result = prime * result + ((fName == null) ? 0 : fName.hashCode());
result = prime * result + ((fValue == null) ? 0 : fValue.hashCode());
return result;
}
if (getClass() != obj.getClass())
return false;
TmfEventField other = (TmfEventField) obj;
- if (fEventContent == null) {
- if (other.fEventContent != null)
- return false;
- } else if (!fEventContent.equals(other.fEventContent))
- return false;
- if (fFieldId == null) {
- if (other.fFieldId != null)
+ if (fName == null) {
+ if (other.fName != null)
return false;
- } else if (!fFieldId.equals(other.fFieldId))
+ } else if (!fName.equals(other.fName))
return false;
if (fValue == null) {
if (other.fValue != null)
@Override
@SuppressWarnings("nls")
public String toString() {
- return "TmfEventField [fFieldId=" + fFieldId + ", fValue=" + fValue + "]";
+ return "TmfEventField [fFieldId=" + fName + ", fValue=" + fValue + "]";
}
}
package org.eclipse.linuxtools.tmf.core.event;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Map;
-
/**
* <b><u>TmfEventType</u></b>
* <p>
*/
public class TmfEventType implements ITmfEventType {
- // ------------------------------------------------------------------------
- // Constants
- // ------------------------------------------------------------------------
-
- public static final String DEFAULT_CONTEXT_ID = "Context"; //$NON-NLS-1$
- public static final String DEFAULT_TYPE_ID = "Type"; //$NON-NLS-1$
-
// ------------------------------------------------------------------------
// Attributes
// ------------------------------------------------------------------------
private String fContext;
private String fTypeId;
- private int fNbFields;
- private Map<String, Integer> fFieldMap;
- private String[] fFieldLabels;
+ private ITmfEventField fRootField;
// ------------------------------------------------------------------------
// Constructors
this(DEFAULT_CONTEXT_ID, DEFAULT_TYPE_ID, null);
}
- /**
- * Full constructor
- *
- * @param context the type context
- * @param typeId the type name
- * @param labels the list of field labels
- */
- public TmfEventType(String context, String typeId, String[] labels) {
- if (context == null || typeId == null)
- throw new IllegalArgumentException();
- fContext = context;
- fTypeId = typeId;
- fFieldLabels = (labels != null) ? labels : new String[] { };
- fNbFields = (fFieldLabels != null) ? fFieldLabels.length : 0;
- fFieldMap = new HashMap<String, Integer>();
- for (int i = 0; i < fNbFields; i++) {
- String id = fFieldLabels[i];
- fFieldMap.put(id, i);
- }
-
- // Register to the event type manager
- TmfEventTypeManager.getInstance().add(context, this);
- }
+ /**
+ * Full constructor
+ *
+ * @param context the type context
+ * @param typeId the type name
+ * @param root the root field
+ */
+ public TmfEventType(String context, String typeId, ITmfEventField root) {
+ if (context == null || typeId == null)
+ throw new IllegalArgumentException();
+ fContext = context;
+ fTypeId = typeId;
+ fRootField = root;
+
+ // Register to the event type manager
+ TmfEventTypeManager.getInstance().add(context, this);
+ }
/**
* Copy constructor
public TmfEventType(TmfEventType type) {
if (type == null)
throw new IllegalArgumentException();
- fContext = type.fContext;
- fTypeId = type.fTypeId;
- fFieldLabels = type.fFieldLabels;
- fNbFields = type.fNbFields;
- fFieldMap = type.fFieldMap;
+ fContext = type.fContext;
+ fTypeId = type.fTypeId;
+ fRootField = type.fRootField;
}
// ------------------------------------------------------------------------
return fContext;
}
- public String getId() {
+ public String getName() {
return fTypeId;
}
- public int getNbFields() {
- return fNbFields;
- }
-
- public String[] getFieldLabels() {
- return fFieldLabels;
+ public ITmfEventField getRootField() {
+ return fRootField;
}
- public String getFieldLabel(int i) throws TmfNoSuchFieldException {
- if (i >= 0 && i < fNbFields)
- return fFieldLabels[i];
- throw new TmfNoSuchFieldException("Invalid index (" + i + ")"); //$NON-NLS-1$//$NON-NLS-2$
+ public String[] getFieldNames() {
+ return (fRootField != null) ? fRootField.getFieldNames() : null;
}
- public int getFieldIndex(String fieldId) throws TmfNoSuchFieldException {
- Integer index = fFieldMap.get(fieldId);
- if (index == null)
- throw (new TmfNoSuchFieldException("Invalid field (" + fieldId + ")")); //$NON-NLS-1$//$NON-NLS-2$
- return index;
+ public String getFieldName(int index) {
+ return (fRootField != null) ? fRootField.getFieldName(index) : null;
}
// ------------------------------------------------------------------------
clone = (TmfEventType) super.clone();
clone.fContext = fContext;
clone.fTypeId = fTypeId;
- // Clone the fields
- clone.fNbFields = fNbFields;
- clone.fFieldLabels = new String[fNbFields];
- clone.fFieldMap = new HashMap<String, Integer>();
- for (int i = 0; i < fNbFields; i++) {
- clone.fFieldLabels[i] = fFieldLabels[i];
- clone.fFieldMap.put(fFieldLabels[i], Integer.valueOf(i));
- }
+ clone.fRootField = (fRootField != null) ? fRootField.clone() : null;
}
catch (CloneNotSupportedException e) {
}
final int prime = 31;
int result = 1;
result = prime * result + ((fContext == null) ? 0 : fContext.hashCode());
- result = prime * result + Arrays.hashCode(fFieldLabels);
- result = prime * result + ((fFieldMap == null) ? 0 : fFieldMap.hashCode());
- result = prime * result + fNbFields;
result = prime * result + ((fTypeId == null) ? 0 : fTypeId.hashCode());
return result;
}
return false;
} else if (!fContext.equals(other.fContext))
return false;
- if (!Arrays.equals(fFieldLabels, other.fFieldLabels))
- return false;
- if (fFieldMap == null) {
- if (other.fFieldMap != null)
- return false;
- } else if (!fFieldMap.equals(other.fFieldMap))
- return false;
- if (fNbFields != other.fNbFields)
- return false;
if (fTypeId == null) {
if (other.fTypeId != null)
return false;
@Override
@SuppressWarnings("nls")
public String toString() {
- return "TmfEventType [fContext=" + fContext + ", fTypeId=" + fTypeId + ", fNbFields="
- + fNbFields + ", fFieldLabels=" + Arrays.toString(fFieldLabels) + "]";
+ return "TmfEventType [fContext=" + fContext + ", fTypeId=" + fTypeId + "]";
}
-// @Override
-// public int hashCode() {
-// return fTypeId.hashCode();
-// }
-//
-// @Override
-// public boolean equals(Object other) {
-// if (!(other instanceof TmfEventType))
-// return false;
-// TmfEventType o = (TmfEventType) other;
-// return fTypeId.equals(o.fTypeId);
-// }
-//
-// @Override
-// @SuppressWarnings("nls")
-// public String toString() {
-// return "[TmfEventType:" + fTypeId + "]";
-// }
-
}
\ No newline at end of file
* <b><u>TmfEventTypeManager</u></b>
* <p>
* The TmfEventTypeManager acts as a central repository for the available
- * event types.
+ * event types. Types are managed in their context space.
* <p>
*/
public final class TmfEventTypeManager {
if (types == null) {
types = new HashMap<String, ITmfEventType>();
}
- types.put(type.getId(), type);
+ types.put(type.getName(), type);
fEventTypes.put(context, types);
}
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2009 Ericsson
- *
- * All rights reserved. This program and the accompanying materials are
- * made available under the terms of the Eclipse Public License v1.0 which
- * accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- * Francois Chouinard - Initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.linuxtools.tmf.core.event;
-
-/**
- * <b><u>TmfNoSuchFieldException</u></b>
- * <p>
- * TODO: Implement me. Please.
- */
-public class TmfNoSuchFieldException extends Exception {
-
- /**
- *
- */
- private static final long serialVersionUID = 2504826473032522133L;
-
- public TmfNoSuchFieldException(String message) {
- super(message);
- }
-}
@Override
@SuppressWarnings("nls")
public String toString() {
- return "TmfSimpleTimestamp [fValue=" + fValue + ", fScale=" + fScale + ", fPrecision=" + fPrecision + "]";
+ return "TmfSimpleTimestamp [fValue=" + fValue + "]";
}
}
/**
* <b><u>TmfTimeRange</u></b>
* <p>
- * A utility class to define time ranges.
+ * A utility class to define and manage time ranges.
*/
public class TmfTimeRange implements Cloneable {
}
// ------------------------------------------------------------------------
- // Accessors
+ // Getters
// ------------------------------------------------------------------------
/**
// Attributes
// ------------------------------------------------------------------------
- protected long fValue; // The timestamp raw value
- protected int fScale; // The time scale
- protected int fPrecision; // The value precision (tolerance)
+ protected long fValue; // The timestamp raw value
+ protected int fScale; // The time scale
+ protected int fPrecision; // The value precision (tolerance)
// ------------------------------------------------------------------------
// Constructors
import java.util.List;\r
\r
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;\r
-import org.eclipse.linuxtools.tmf.core.event.TmfNoSuchFieldException;\r
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;\r
\r
\r
\r
@Override\r
public boolean matches(TmfEvent event) {\r
- try {\r
- Object value = event.getContent().getField(fField);\r
- if (value == null) {\r
- return false ^ fNot;\r
- }\r
- if (fType == Type.NUM) {\r
- if (fValueNumber instanceof Number) {\r
- if (value instanceof Number) {\r
- Double valueDouble = ((Number) value).doubleValue();\r
- return (valueDouble.compareTo(fValueNumber.doubleValue()) == fResult) ^ fNot;\r
- } else {\r
- try {\r
- Double valueDouble = NumberFormat.getInstance().parse(value.toString()).doubleValue();\r
- return (valueDouble.compareTo(fValueNumber.doubleValue()) == fResult) ^ fNot;\r
- } catch (ParseException e) {\r
- }\r
- }\r
- }\r
- } else if (fType == Type.ALPHA) {\r
- String valueString = value.toString();\r
- return (valueString.compareTo(fValue.toString()) == fResult) ^ fNot;\r
- } else if (fType == Type.TIMESTAMP) {\r
- if (fValueTimestamp instanceof TmfTimestamp) {\r
- if (value instanceof TmfTimestamp) {\r
- TmfTimestamp valueTimestamp = (TmfTimestamp) value;\r
- return (valueTimestamp.compareTo(fValueTimestamp, false) == fResult) ^ fNot;\r
- } else {\r
- try {\r
- TmfTimestamp valueTimestamp = new TmfTimestamp((long) (1E9 * NumberFormat.getInstance().parse(value.toString()).doubleValue()));\r
- return (valueTimestamp.compareTo(fValueTimestamp, false) == fResult) ^ fNot;\r
- } catch (ParseException e) {\r
- }\r
- }\r
- }\r
- }\r
- } catch (TmfNoSuchFieldException e) {\r
- }\r
- return false ^ fNot;\r
+ Object value = event.getContent().getField(fField).getValue();\r
+ if (value == null) {\r
+ return false ^ fNot;\r
+ }\r
+ if (fType == Type.NUM) {\r
+ if (fValueNumber instanceof Number) {\r
+ if (value instanceof Number) {\r
+ Double valueDouble = ((Number) value).doubleValue();\r
+ return (valueDouble.compareTo(fValueNumber.doubleValue()) == fResult) ^ fNot;\r
+ } else {\r
+ try {\r
+ Double valueDouble = NumberFormat.getInstance().parse(value.toString())\r
+ .doubleValue();\r
+ return (valueDouble.compareTo(fValueNumber.doubleValue()) == fResult)\r
+ ^ fNot;\r
+ } catch (ParseException e) {\r
+ }\r
+ }\r
+ }\r
+ } else if (fType == Type.ALPHA) {\r
+ String valueString = value.toString();\r
+ return (valueString.compareTo(fValue.toString()) == fResult) ^ fNot;\r
+ } else if (fType == Type.TIMESTAMP) {\r
+ if (fValueTimestamp instanceof TmfTimestamp) {\r
+ if (value instanceof TmfTimestamp) {\r
+ TmfTimestamp valueTimestamp = (TmfTimestamp) value;\r
+ return (valueTimestamp.compareTo(fValueTimestamp, false) == fResult) ^ fNot;\r
+ } else {\r
+ try {\r
+ TmfTimestamp valueTimestamp = new TmfTimestamp((long) (1E9 * NumberFormat\r
+ .getInstance().parse(value.toString()).doubleValue()));\r
+ return (valueTimestamp.compareTo(fValueTimestamp, false) == fResult) ^ fNot;\r
+ } catch (ParseException e) {\r
+ }\r
+ }\r
+ }\r
+ }\r
+ return false ^ fNot;\r
}\r
\r
@Override\r
import java.util.List;\r
\r
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;\r
-import org.eclipse.linuxtools.tmf.core.event.TmfNoSuchFieldException;\r
\r
\r
public class TmfFilterContainsNode extends TmfFilterTreeNode {\r
\r
@Override\r
public boolean matches(TmfEvent event) {\r
- try {\r
- Object value = event.getContent().getField(fField);\r
- if (value == null) {\r
- return false ^ fNot;\r
- }\r
- String valueString = value.toString();\r
- if (fIgnoreCase) {\r
- return valueString.toUpperCase().contains(fValueUpperCase) ^ fNot;\r
- } else {\r
- return valueString.contains(fValue) ^ fNot;\r
- }\r
- } catch (TmfNoSuchFieldException e) {\r
- return false ^ fNot;\r
- }\r
+ Object value = event.getContent().getField(fField);\r
+ if (value == null) {\r
+ return false ^ fNot;\r
+ }\r
+ String valueString = value.toString();\r
+ if (fIgnoreCase) {\r
+ return valueString.toUpperCase().contains(fValueUpperCase) ^ fNot;\r
+ } else {\r
+ return valueString.contains(fValue) ^ fNot;\r
+ }\r
}\r
\r
@Override\r
import java.util.List;\r
\r
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;\r
-import org.eclipse.linuxtools.tmf.core.event.TmfNoSuchFieldException;\r
\r
\r
public class TmfFilterEqualsNode extends TmfFilterTreeNode {\r
\r
@Override\r
public boolean matches(TmfEvent event) {\r
- try {\r
- Object value = event.getContent().getField(fField);\r
- if (value == null) {\r
- return false ^ fNot;\r
- }\r
- String valueString = value.toString();\r
- if (valueString == null) {\r
- return false ^ fNot;\r
- }\r
- if (fIgnoreCase) {\r
- return valueString.equalsIgnoreCase(fValue) ^ fNot;\r
- } else {\r
- return valueString.equals(fValue) ^ fNot;\r
- }\r
- } catch (TmfNoSuchFieldException e) {\r
- return false ^ fNot;\r
- }\r
+ Object value = event.getContent().getField(fField);\r
+ if (value == null) {\r
+ return false ^ fNot;\r
+ }\r
+ String valueString = value.toString();\r
+ if (valueString == null) {\r
+ return false ^ fNot;\r
+ }\r
+ if (fIgnoreCase) {\r
+ return valueString.equalsIgnoreCase(fValue) ^ fNot;\r
+ } else {\r
+ return valueString.equals(fValue) ^ fNot;\r
+ }\r
}\r
\r
@Override\r
if (fType.contains(":")) { //$NON-NLS-1$\r
// special case for custom parsers\r
if (fType.startsWith(event.getClass().getCanonicalName())) {\r
- if (fType.endsWith(event.getType().getId())) {\r
+ if (fType.endsWith(event.getType().getName())) {\r
match = true;\r
}\r
}\r
import java.util.regex.PatternSyntaxException;\r
\r
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;\r
-import org.eclipse.linuxtools.tmf.core.event.TmfNoSuchFieldException;\r
\r
\r
public class TmfFilterMatchesNode extends TmfFilterTreeNode {\r
\r
@Override\r
public boolean matches(TmfEvent event) {\r
- if (fPattern == null) {\r
- return false ^ fNot;\r
- }\r
- try {\r
- Object value = event.getContent().getField(fField);\r
- if (value == null) {\r
- return false ^ fNot;\r
- }\r
- String valueString = value.toString();\r
- return fPattern.matcher(valueString).matches() ^ fNot;\r
- } catch (TmfNoSuchFieldException e) {\r
- return false ^ fNot;\r
- }\r
+ if (fPattern == null) {\r
+ return false ^ fNot;\r
+ }\r
+ Object value = event.getContent().getField(fField);\r
+ if (value == null) {\r
+ return false ^ fNot;\r
+ }\r
+ String valueString = value.toString();\r
+ return fPattern.matcher(valueString).matches() ^ fNot;\r
}\r
\r
@Override\r
package org.eclipse.linuxtools.tmf.core.request;
-import org.eclipse.linuxtools.tmf.core.event.TmfDataItem;
+import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
/**
* <b><u>ITmfDataRequest</u></b>
* <p>
* TODO: Implement me. Please.
*/
-public interface ITmfDataRequest<T extends TmfDataItem> {
+public interface ITmfDataRequest<T extends TmfEvent> {
// ------------------------------------------------------------------------
// Constants
import java.util.Vector;
-import org.eclipse.linuxtools.tmf.core.event.TmfDataItem;
+import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
/**
* <b><u>TmfCoalescedDataRequest</u></b>
* <p>
* TODO: Implement me. Please.
*/
-public class TmfCoalescedDataRequest<T extends TmfDataItem> extends TmfDataRequest<T> {
+public class TmfCoalescedDataRequest<T extends TmfEvent> extends TmfDataRequest<T> {
// ------------------------------------------------------------------------
// Attributes
import java.util.concurrent.CountDownLatch;
import org.eclipse.linuxtools.tmf.core.Tracer;
-import org.eclipse.linuxtools.tmf.core.event.TmfDataItem;
+import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
/**
* <b><u>TmfDataRequest</u></b>
*
* TODO: Implement request failures (codes, etc...)
*/
-public abstract class TmfDataRequest<T extends TmfDataItem> implements ITmfDataRequest<T> {
+public abstract class TmfDataRequest<T extends TmfEvent> implements ITmfDataRequest<T> {
// ------------------------------------------------------------------------
// Constants
import org.eclipse.jface.viewers.ColumnLabelProvider;
import org.eclipse.jface.viewers.ViewerComparator;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventContent;
+import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.util.TmfFixedArray;
private final String fSource = "Source";
- private final TmfEventType fType1 = new TmfEventType(fContext, fTypeId1, fLabels);
- private final TmfEventType fType2 = new TmfEventType(fContext, fTypeId1, fLabels);
- private final TmfEventType fType3 = new TmfEventType(fContext, fTypeId2, fLabels);
+ private final TmfEventType fType1 = new TmfEventType(fContext, fTypeId1, TmfEventField.makeRoot(fLabels));
+ private final TmfEventType fType2 = new TmfEventType(fContext, fTypeId1, TmfEventField.makeRoot(fLabels));
+ private final TmfEventType fType3 = new TmfEventType(fContext, fTypeId2, TmfEventField.makeRoot(fLabels));
private final String fReference = "Some reference";
private final TmfEvent fEvent2;
private final TmfEvent fEvent3;
- private final TmfEventContent fContent1;
- private final TmfEventContent fContent2;
- private final TmfEventContent fContent3;
+ private final TmfEventField fContent1;
+ private final TmfEventField fContent2;
+ private final TmfEventField fContent3;
private final TmfBaseStatisticsTree fStatsData;
fTestName = name;
fEvent1 = new TmfEvent(fTimestamp1, fSource, fType1, fReference);
- fContent1 = new TmfEventContent(fEvent1, "Some content");
+ fContent1 = new TmfEventField(ITmfEventField.ROOT_ID, "Some content");
fEvent1.setContent(fContent1);
fEvent2 = new TmfEvent(fTimestamp2, fSource, fType2, fReference);
- fContent2 = new TmfEventContent(fEvent2, "Some other content");
+ fContent2 = new TmfEventField(ITmfEventField.ROOT_ID, "Some other content");
fEvent2.setContent(fContent2);
fEvent3 = new TmfEvent(fTimestamp3, fSource, fType3, fReference);
- fContent3 = new TmfEventContent(fEvent3, "Some other different content");
+ fContent3 = new TmfEventField(ITmfEventField.ROOT_ID, "Some other different content");
fEvent3.setContent(fContent3);
fStatsData = new TmfBaseStatisticsTree();
import junit.framework.TestCase;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventContent;
+import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.util.TmfFixedArray;
private final String fSource = "Source";
- private final TmfEventType fType1 = new TmfEventType(fContext, fTypeId1, fLabels);
- private final TmfEventType fType2 = new TmfEventType(fContext, fTypeId1, fLabels);
- private final TmfEventType fType3 = new TmfEventType(fContext, fTypeId2, fLabels);
+ private final TmfEventType fType1 = new TmfEventType(fContext, fTypeId1, TmfEventField.makeRoot(fLabels));
+ private final TmfEventType fType2 = new TmfEventType(fContext, fTypeId1, TmfEventField.makeRoot(fLabels));
+ private final TmfEventType fType3 = new TmfEventType(fContext, fTypeId2, TmfEventField.makeRoot(fLabels));
private final String fReference = "Some reference";
private final TmfEvent fEvent2;
private final TmfEvent fEvent3;
- private final TmfEventContent fContent1;
- private final TmfEventContent fContent2;
- private final TmfEventContent fContent3;
+ private final TmfEventField fContent1;
+ private final TmfEventField fContent2;
+ private final TmfEventField fContent3;
private final TmfBaseStatisticsTree fStatsData;
fTestName = name;
fEvent1 = new TmfEvent(fTimestamp1, fSource, fType1, fReference);
- fContent1 = new TmfEventContent(fEvent1, "Some content");
+ fContent1 = new TmfEventField(ITmfEventField.ROOT_ID, "Some content");
fEvent1.setContent(fContent1);
fEvent2 = new TmfEvent(fTimestamp2, fSource, fType2, fReference);
- fContent2 = new TmfEventContent(fEvent2, "Some other content");
+ fContent2 = new TmfEventField(ITmfEventField.ROOT_ID, "Some other content");
fEvent2.setContent(fContent2);
fEvent3 = new TmfEvent(fTimestamp3, fSource, fType3, fReference);
- fContent3 = new TmfEventContent(fEvent3, "Some other different content");
+ fContent3 = new TmfEventField(ITmfEventField.ROOT_ID, "Some other different content");
fEvent3.setContent(fContent3);
fStatsData = new TmfBaseStatisticsTree();
fStatsData.reset(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes));
assertEquals("reset", 0, fStatsData.getChildren(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes)).size());
- assertNull("reset", fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fType1.getId())));
- assertNull("reset", fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fType3.getId())));
+ assertNull("reset", fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fType1.getName())));
+ assertNull("reset", fStatsData.get(new TmfFixedArray<String>(fTestName, Messages.TmfStatisticsData_EventTypes, fType3.getName())));
fStatsData.reset(new TmfFixedArray<String>(fTestName));
import junit.framework.TestCase;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventContent;
+import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.util.TmfFixedArray;
private final String fSource = "Source";
- private final TmfEventType fType1 = new TmfEventType(fContext, fTypeId1, fLabels);
- private final TmfEventType fType2 = new TmfEventType(fContext, fTypeId1, fLabels);
- private final TmfEventType fType3 = new TmfEventType(fContext, fTypeId2, fLabels);
+ private final TmfEventType fType1 = new TmfEventType(fContext, fTypeId1, TmfEventField.makeRoot(fLabels));
+ private final TmfEventType fType2 = new TmfEventType(fContext, fTypeId1, TmfEventField.makeRoot(fLabels));
+ private final TmfEventType fType3 = new TmfEventType(fContext, fTypeId2, TmfEventField.makeRoot(fLabels));
private final String fReference = "Some reference";
private final TmfEvent fEvent2;
private final TmfEvent fEvent3;
- private final TmfEventContent fContent1;
- private final TmfEventContent fContent2;
- private final TmfEventContent fContent3;
+ private final TmfEventField fContent1;
+ private final TmfEventField fContent2;
+ private final TmfEventField fContent3;
private final TmfBaseStatisticsTree fStatsData;
fTestName = name;
fEvent1 = new TmfEvent(fTimestamp1, fSource, fType1, fReference);
- fContent1 = new TmfEventContent(fEvent1, "Some content");
+ fContent1 = new TmfEventField(ITmfEventField.ROOT_ID, "Some content");
fEvent1.setContent(fContent1);
fEvent2 = new TmfEvent(fTimestamp2, fSource, fType2, fReference);
- fContent2 = new TmfEventContent(fEvent2, "Some other content");
+ fContent2 = new TmfEventField(ITmfEventField.ROOT_ID, "Some other content");
fEvent2.setContent(fContent2);
fEvent3 = new TmfEvent(fTimestamp3, fSource, fType3, fReference);
- fContent3 = new TmfEventContent(fEvent3, "Some other different content");
+ fContent3 = new TmfEventField(ITmfEventField.ROOT_ID, "Some other different content");
fEvent3.setContent(fContent3);
fStatsData = new TmfBaseStatisticsTree();
import junit.framework.TestCase;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventContent;
+import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.util.TmfFixedArray;
private final String fSource = "Source";
- private final TmfEventType fType1 = new TmfEventType(fContext, fTypeId1, fLabels);
- private final TmfEventType fType2 = new TmfEventType(fContext, fTypeId2, fLabels);
+ private final TmfEventType fType1 = new TmfEventType(fContext, fTypeId1, TmfEventField.makeRoot(fLabels));
+ private final TmfEventType fType2 = new TmfEventType(fContext, fTypeId2, TmfEventField.makeRoot(fLabels));
private final String fReference = "Some reference";
private final TmfEvent fEvent1;
private final TmfEvent fEvent2;
- private final TmfEventContent fContent1;
- private final TmfEventContent fContent2;
+ private final TmfEventField fContent1;
+ private final TmfEventField fContent2;
private final TmfBaseStatisticsTree fStatsData;
fTestName = name;
fEvent1 = new TmfEvent(fTimestamp1, fSource, fType1, fReference);
- fContent1 = new TmfEventContent(fEvent1, "Some content");
+ fContent1 = new TmfEventField(ITmfEventField.ROOT_ID, "Some content");
fEvent1.setContent(fContent1);
fEvent2 = new TmfEvent(fTimestamp2, fSource, fType2, fReference);
- fContent2 = new TmfEventContent(fEvent2, "Some other content");
+ fContent2 = new TmfEventField(ITmfEventField.ROOT_ID, "Some other content");
fEvent2.setContent(fContent2);
fStatsData = new TmfBaseStatisticsTree();
import java.io.IOException;
import java.io.RandomAccessFile;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventContent;
import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
String[] labels = {"sender", "receiver", "signal"};
- TmfEventType tmfEventType = new TmfEventType("UnitTest", type, labels);
- TmfEvent tmfEvent = new TmfEvent(new TmfTimestamp(ts, (byte)-9), source, tmfEventType, reference);
+ TmfEventType tmfEventType = new TmfEventType("UnitTest", type, TmfEventField.makeRoot(labels));
+ TmfEvent tmfEvent = new TmfEvent(new TmfTimestamp(ts, -9), source, tmfEventType, reference);
String content = "[";
content += sender;
content += "," + signal;
content += "]";
- TmfEventContent tmfContent = new TmfEventContent(tmfEvent, content) {
- @Override
- public void parseContent() {
- String raw = fRawContent.toString();
- int i = raw.indexOf(",");
- String sender = raw.substring(1, i);
- int k = raw.indexOf(",", i+1);
- String receiver = raw.substring(i+1, k);
- i = raw.indexOf(",", k+1);
- String signal = raw.substring(k+1, raw.length() - 1);
- fFields = new TmfEventField[3];
- fFields[0] = new TmfEventField(this, "sender", sender);
- fFields[1] = new TmfEventField(this, "receiver", receiver);;
- fFields[2] = new TmfEventField(this, "signal", signal);;
- }
- };
+ // Pre-parse the content
+ TmfEventField[] fields = new TmfEventField[3];
+ fields[0] = new TmfEventField("sender", sender);
+ fields[1] = new TmfEventField("receiver", receiver);
+ fields[2] = new TmfEventField("signal", signal);
+
+ ITmfEventField tmfContent = new TmfEventField(ITmfEventField.ROOT_ID, content, fields);
tmfEvent.setContent(tmfContent);
return tmfEvent;
String value = fData.get(outputColumn.name);\r
if (outputColumn.name.equals(CustomTraceDefinition.TAG_TIMESTAMP) && date != null) {\r
SimpleDateFormat dateFormat = new SimpleDateFormat(fDefinition.timeStampOutputFormat);\r
- fColumnData[i++] = new TmfEventField(getContent(), outputColumn.name, dateFormat.format(date));\r
+ fColumnData[i++] = new TmfEventField(outputColumn.name, dateFormat.format(date));\r
} else {\r
- fColumnData[i++] = new TmfEventField(getContent(), outputColumn.name, (value != null ? value : "")); //$NON-NLS-1$\r
+ fColumnData[i++] = new TmfEventField(outputColumn.name, (value != null ? value : "")); //$NON-NLS-1$\r
}\r
}\r
fData = null;\r
package org.eclipse.linuxtools.tmf.ui.parsers.custom;\r
\r
-import java.util.Arrays;\r
+import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;\r
+import org.eclipse.linuxtools.tmf.core.event.TmfEventField;\r
\r
-import org.eclipse.linuxtools.tmf.core.event.TmfEventContent;\r
-\r
-public class CustomEventContent extends TmfEventContent {\r
+public class CustomEventContent extends TmfEventField {\r
\r
+ CustomEvent fParent;\r
+ \r
public CustomEventContent(CustomEvent parent, String content) {\r
- super(parent, content);\r
- }\r
-\r
- @Override\r
- protected void parseContent() {\r
- CustomEvent event = (CustomEvent) fParentEvent;\r
- fFields = event.extractItemFields();\r
+ super(ITmfEventField.ROOT_ID, content);\r
+ fParent = parent;\r
}\r
\r
- @Override\r
- public String toString() {\r
- return Arrays.toString(getFields());\r
- }\r
+// @Override\r
+// protected void parseContent() {\r
+// CustomEvent event = (CustomEvent) fParentEvent;\r
+// fFields = event.extractItemFields();\r
+// }\r
+//\r
+// @Override\r
+// public String toString() {\r
+// return Arrays.toString(getFields());\r
+// }\r
\r
}\r
package org.eclipse.linuxtools.tmf.ui.parsers.custom;\r
\r
+import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;\r
+import org.eclipse.linuxtools.tmf.core.event.TmfEventField;\r
import org.eclipse.linuxtools.tmf.core.event.TmfEventType;\r
\r
public abstract class CustomEventType extends TmfEventType {\r
private static String CONTEXT_ID = "CustomEventType"; //$NON-NLS-1$\r
\r
public CustomEventType(CustomTraceDefinition definition) {\r
- super(CONTEXT_ID, definition.definitionName, getLabels(definition));\r
+ super(CONTEXT_ID, definition.definitionName, getRootField(definition));\r
}\r
\r
- private static String[] getLabels(CustomTraceDefinition definition) {\r
- String[] labels = new String[definition.outputs.size()];\r
- for (int i = 0; i < labels.length; i++) {\r
- labels[i] = definition.outputs.get(i).name;\r
+ private static ITmfEventField getRootField(CustomTraceDefinition definition) {\r
+ ITmfEventField[] fields = new ITmfEventField[definition.outputs.size()];\r
+ for (int i = 0; i < fields.length; i++) {\r
+ fields[i] = new TmfEventField(definition.outputs.get(i).name, null);\r
}\r
- return labels;\r
+ ITmfEventField rootField = new TmfEventField(ITmfEventField.ROOT_ID, fields);\r
+ return rootField;\r
}\r
\r
}\r
}\r
}\r
}\r
- ((StringBuffer) event.getContent().getRawContent()).append("\n").append(line); //$NON-NLS-1$\r
+ ((StringBuffer) event.getContent().getValue()).append("\n").append(line); //$NON-NLS-1$\r
}\r
}\r
rawPos = context.raFile.getFilePointer();\r
Element element = parseElementBuffer(elementBuffer);\r
\r
event = extractEvent(element, fRecordInputElement);\r
- ((StringBuffer) event.getContent().getRawContent()).append(elementBuffer);\r
+ ((StringBuffer) event.getContent().getValue()).append(elementBuffer);\r
\r
String line;\r
String recordElementStart = "<" + fRecordInputElement.elementName; //$NON-NLS-1$\r
import org.eclipse.jface.resource.LocalResourceManager;\r
import org.eclipse.linuxtools.tmf.core.component.ITmfDataProvider;\r
import org.eclipse.linuxtools.tmf.core.component.TmfComponent;\r
-import org.eclipse.linuxtools.tmf.core.event.ITmfEventContent;\r
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;\r
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;\r
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;\r
-import org.eclipse.linuxtools.tmf.core.event.TmfEventContent;\r
import org.eclipse.linuxtools.tmf.core.event.TmfEventField;\r
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;\r
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;\r
\r
// Set the default column field ids if this is not a subclass\r
if (Arrays.equals(columnData, COLUMN_DATA)) {\r
- fTable.getColumns()[0].setData(Key.FIELD_ID, TmfEventContent.FIELD_ID_TIMESTAMP);\r
- fTable.getColumns()[1].setData(Key.FIELD_ID, TmfEventContent.FIELD_ID_SOURCE);\r
- fTable.getColumns()[2].setData(Key.FIELD_ID, TmfEventContent.FIELD_ID_TYPE);\r
- fTable.getColumns()[3].setData(Key.FIELD_ID, TmfEventContent.FIELD_ID_REFERENCE);\r
- fTable.getColumns()[4].setData(Key.FIELD_ID, TmfEventContent.FIELD_ID_CONTENT);\r
+ fTable.getColumns()[0].setData(Key.FIELD_ID, ITmfEvent.EVENT_FIELD_TIMESTAMP);\r
+ fTable.getColumns()[1].setData(Key.FIELD_ID, ITmfEvent.EVENT_FIELD_SOURCE);\r
+ fTable.getColumns()[2].setData(Key.FIELD_ID, ITmfEvent.EVENT_FIELD_TYPE);\r
+ fTable.getColumns()[3].setData(Key.FIELD_ID, ITmfEvent.EVENT_FIELD_REFERENCE);\r
+ fTable.getColumns()[4].setData(Key.FIELD_ID, ITmfEvent.EVENT_FIELD_CONTENT);\r
}\r
\r
// Set the frozen row for header row\r
protected TmfEventField[] extractItemFields(TmfEvent event) {\r
TmfEventField[] fields = new TmfEventField[0];\r
if (event != null) {\r
- ITmfEventContent content = event.getContent();\r
fields = new TmfEventField[] {\r
- new TmfEventField(content, TmfEventContent.FIELD_ID_TIMESTAMP, ((Long) event.getTimestamp().getValue()).toString()),\r
- new TmfEventField(content, TmfEventContent.FIELD_ID_SOURCE, event.getSource()),\r
- new TmfEventField(content, TmfEventContent.FIELD_ID_TYPE, event.getType().getId()),\r
- new TmfEventField(content, TmfEventContent.FIELD_ID_REFERENCE, event.getReference()),\r
- new TmfEventField(content, TmfEventContent.FIELD_ID_CONTENT, event.getContent().toString())\r
+ new TmfEventField(ITmfEvent.EVENT_FIELD_TIMESTAMP, ((Long) event.getTimestamp().getValue()).toString()),\r
+ new TmfEventField(ITmfEvent.EVENT_FIELD_SOURCE, event.getSource()),\r
+ new TmfEventField(ITmfEvent.EVENT_FIELD_TYPE, event.getType().getName()),\r
+ new TmfEventField(ITmfEvent.EVENT_FIELD_REFERENCE, event.getReference()),\r
+ new TmfEventField(ITmfEvent.EVENT_FIELD_CONTENT, event.getContent().toString())\r
};\r
}\r
return fields;\r
TmfEvent event = (TmfEvent) ce.createExecutableExtension(TmfTraceType.EVENT_TYPE_ATTR);\r
ITmfEventType eventType = event.getType();\r
if (eventType != null) {\r
- for (String field : eventType.getFieldLabels()) {\r
+ for (String field : eventType.getRootField().getFieldNames()) {\r
fieldsList.add(field);\r
}\r
}\r
if (eventType != null) {\r
fieldsList.add("[" + TmfTraceType.getCategoryName(ce.getAttribute(TmfTraceType.CATEGORY_ATTR)) + //$NON-NLS-1$\r
" : " + ce.getAttribute(TmfTraceType.NAME_ATTR) + "]"); //$NON-NLS-1$ //$NON-NLS-2$\r
- for (String field : eventType.getFieldLabels()) {\r
+ for (String field : eventType.getFieldNames()) {\r
fieldsList.add(field);\r
}\r
fieldsList.add(""); //$NON-NLS-1$\r
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
-import org.eclipse.linuxtools.tmf.core.event.TmfNoSuchFieldException;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.experiment.TmfExperiment;
//type = .*RECEIVE.* or .*SEND.*
//content = sender:<sender name>:receiver:<receiver name>,signal:<signal name>
String eventType = tmfEvent.getType().toString();
- if (eventType.contains(Messages.TmfUml2SDSyncCloader_EventTypeSend) ||
- eventType.contains(Messages.TmfUml2SDSyncCloader_EventTypeReceive)) {
- try {
- Object sender = tmfEvent.getContent().getField(Messages.TmfUml2SDSyncCloader_FieldSender);
- Object receiver = tmfEvent.getContent().getField(Messages.TmfUml2SDSyncCloader_FieldReceiver);
- Object name = tmfEvent.getContent().getField(Messages.TmfUml2SDSyncCloader_FieldSignal);
- if ((sender instanceof TmfEventField) && (receiver instanceof TmfEventField) && (name instanceof TmfEventField)) {
- ITmfSyncSequenceDiagramEvent sdEvent = new TmfSyncSequenceDiagramEvent(tmfEvent,
- ((TmfEventField)sender).getValue().toString(),
- ((TmfEventField)receiver).getValue().toString(),
- ((TmfEventField)name).getValue().toString());
-
- return sdEvent;
- }
- } catch (TmfNoSuchFieldException e) {
- }
+ if (eventType.contains(Messages.TmfUml2SDSyncCloader_EventTypeSend) || eventType.contains(Messages.TmfUml2SDSyncCloader_EventTypeReceive)) {
+ Object sender = tmfEvent.getContent().getField(Messages.TmfUml2SDSyncCloader_FieldSender);
+ Object receiver = tmfEvent.getContent().getField(Messages.TmfUml2SDSyncCloader_FieldReceiver);
+ Object name = tmfEvent.getContent().getField(Messages.TmfUml2SDSyncCloader_FieldSignal);
+ if ((sender instanceof TmfEventField) && (receiver instanceof TmfEventField) && (name instanceof TmfEventField)) {
+ ITmfSyncSequenceDiagramEvent sdEvent = new TmfSyncSequenceDiagramEvent(tmfEvent,
+ ((TmfEventField) sender).getValue().toString(),
+ ((TmfEventField) receiver).getValue().toString(),
+ ((TmfEventField) name).getValue().toString());
+
+ return sdEvent;
+ }
}
return null;
}
projects / deliverable / tracecompass.git / commitdiff
