Examples with ITmfEventType org.eclipse.tracecompass.tmf.core.event.ITmfEventType used on opensource projects

Example 1 with ITmfEventType

use of org.eclipse.tracecompass.tmf.core.event.ITmfEventType in project tracecompass by tracecompass.

the class TmfEventTypeTest method testDefaultConstructor.

// ------------------------------------------------------------------------
// Constructors
// ------------------------------------------------------------------------
@Test
public void testDefaultConstructor() {
    final ITmfEventType type = new TmfEventType();
    assertEquals("getName", ITmfEventType.DEFAULT_TYPE_ID, type.getName());
    assertNull("getRootField", type.getRootField());
    assertEquals("getFieldNames", 0, type.getFieldNames().size());
}

Example 2 with ITmfEventType

use of org.eclipse.tracecompass.tmf.core.event.ITmfEventType in project tracecompass by tracecompass.

the class TmfEventTypeTest method testFullConstructor.

@Test
public void testFullConstructor() {
    final ITmfEventType type0 = new TmfEventType(fTypeId1, TmfEventField.makeRoot(fLabels0));
    assertEquals("getName", fTypeId1, type0.getName());
    assertEquals("getRootField", TmfEventField.makeRoot(fLabels0), type0.getRootField());
    final Collection<String> labels0 = type0.getFieldNames();
    assertEquals("getFieldNames length", fLabels0.length, labels0.size());
    assertArrayEquals(fLabels0, labels0.toArray(new String[labels0.size()]));
    final ITmfEventType type1 = new TmfEventType(fTypeId1, TmfEventField.makeRoot(fLabels1));
    assertEquals("getName", fTypeId1, type1.getName());
    assertEquals("getRootField", TmfEventField.makeRoot(fLabels1), type1.getRootField());
    final Collection<String> labels1 = type1.getFieldNames();
    assertEquals("getFieldNames length", fLabels1.length, labels1.size());
    assertArrayEquals(fLabels1, labels1.toArray(new String[labels1.size()]));
    final ITmfEventType type2 = new TmfEventType(fTypeId2, TmfEventField.makeRoot(fLabels2));
    assertEquals("getName", fTypeId2, type2.getName());
    assertEquals("getRootField", TmfEventField.makeRoot(fLabels2), type2.getRootField());
    final Collection<String> labels2 = type2.getFieldNames();
    assertEquals("getFieldNames length", fLabels2.length, labels2.size());
    assertArrayEquals(fLabels2, labels2.toArray(new String[labels2.size()]));
}

Example 3 with ITmfEventType

use of org.eclipse.tracecompass.tmf.core.event.ITmfEventType in project tracecompass by tracecompass.

the class TmfXmlTraceStub method getNext.

@Override
@Nullable
public synchronized ITmfEvent getNext(@Nullable ITmfContext context) {
    if (context == null) {
        return null;
    }
    final ITmfContext savedContext = new TmfContext(context.getLocation(), context.getRank());
    CustomXmlEvent event = fTrace.getNext(context);
    if (event == null) {
        return null;
    }
    /* Translate the content of the event */
    /* The "fields" field contains a | separated list of field names */
    /* The "values" field contains a | separated list of field values */
    /* the "type" field contains a | separated list of field types */
    ITmfEventField content = event.getContent();
    if (content == null) {
        return null;
    }
    String fieldString = getStringValue(content, FIELD_NAMES_FIELD);
    String valueString = getStringValue(content, VALUES_FIELD);
    String typeString = getStringValue(content, TYPES_FIELD);
    String[] fields = fieldString.split(VALUES_SEPARATOR);
    String[] values = valueString.split(VALUES_SEPARATOR);
    String[] types = typeString.split(VALUES_SEPARATOR);
    ITmfEventField[] fieldsArray = new TmfEventField[fields.length];
    for (int i = 0; i < fields.length; i++) {
        String value = EMPTY;
        if (values.length > i) {
            value = values[i];
        }
        String type = null;
        if (types.length > i) {
            type = types[i];
        }
        Object val = value;
        if (type != null) {
            switch(type) {
                case TYPE_INTEGER:
                    {
                        try {
                            val = Integer.valueOf(value);
                        } catch (NumberFormatException e) {
                            // $NON-NLS-1$
                            Activator.logError(String.format("Get next XML event: cannot cast value %s to integer", value), e);
                            val = 0;
                        }
                        break;
                    }
                case TYPE_LONG:
                    {
                        try {
                            val = Long.valueOf(value);
                        } catch (NumberFormatException e) {
                            // $NON-NLS-1$
                            Activator.logError(String.format("Get next XML event: cannot cast value %s to long", value), e);
                            val = 0L;
                        }
                        break;
                    }
                case TYPE_LONG_ARRAY:
                    {
                        try {
                            String[] split = value.split(",");
                            long[] arr = new long[split.length];
                            for (int j = 0; j < split.length; j++) {
                                arr[j] = Long.valueOf(split[j]);
                            }
                            val = arr;
                        } catch (NumberFormatException e) {
                            // $NON-NLS-1$
                            Activator.logError(String.format("Get next XML event: cannot cast one of the comma-separated values of %s to long", value), e);
                            val = new long[0];
                        }
                        break;
                    }
                case TYPE_INT_ARRAY:
                    {
                        try {
                            String[] split = value.split(",");
                            int[] arr = new int[split.length];
                            for (int j = 0; j < split.length; j++) {
                                arr[j] = Integer.valueOf(split[j]);
                            }
                            val = arr;
                        } catch (NumberFormatException e) {
                            // $NON-NLS-1$
                            Activator.logError(String.format("Get next XML event: cannot cast one of the comma-separated values of %s to int", value), e);
                            val = new int[0];
                        }
                        break;
                    }
                default:
                    break;
            }
        }
        fieldsArray[i] = new TmfEventField(checkNotNull(fields[i]), val, null);
    }
    /*
         * Generate the aspects for this trace if it is the 'set_aspects'
         * definition
         */
    if (fTrace.getDefinition() != fDefinition) {
        generateAspects(fieldsArray);
        return null;
    }
    /* Create a new event with new fields and name */
    ITmfEventType customEventType = event.getType();
    String eventName = getStringValue(content, EVENT_NAME_FIELD);
    TmfEventType eventType = new TmfEventType(eventName, customEventType.getRootField());
    ITmfEventField eventFields = new CustomEventContent(content.getName(), content.getValue(), fieldsArray);
    /*
         * TODO: Timestamps for these traces are in nanos, but since the
         * CustomXmlTrace does not support this format, the timestamp of the
         * original is in second and we need to convert it. We should do that at
         * the source when it is supported
         */
    TmfEvent newEvent = new TmfEvent(this, ITmfContext.UNKNOWN_RANK, event.getTimestamp(), eventType, eventFields);
    updateAttributes(savedContext, event);
    return newEvent;
}

Example 4 with ITmfEventType

use of org.eclipse.tracecompass.tmf.core.event.ITmfEventType in project tracecompass by tracecompass.

the class CustomEvent method processData.

// ------------------------------------------------------------------------
// Other operations
// ------------------------------------------------------------------------
private void processData() {
    // Remove the values as they are processed, so we can process the extra values at the end
    String timestampString = fData.remove(Tag.TIMESTAMP);
    String timestampInputFormat = fData.remove(Key.TIMESTAMP_INPUT_FORMAT);
    ITmfTimestamp timestamp = null;
    if (timestampInputFormat != null && timestampString != null) {
        TmfTimestampFormat timestampFormat = new TmfTimestampFormat(timestampInputFormat);
        try {
            long time = timestampFormat.parseValue(timestampString);
            timestamp = TmfTimestamp.fromNanos(getTrace().getTimestampTransform().transform(time));
            setTimestamp(timestamp);
        } catch (ParseException e) {
            setTimestamp(TmfTimestamp.ZERO);
        }
    } else {
        setTimestamp(TmfTimestamp.ZERO);
    }
    // Update the custom event type of this event if set
    String eventName = fData.remove(Tag.EVENT_TYPE);
    ITmfEventType type = getType();
    if (eventName != null && type instanceof CustomEventType) {
        ((CustomEventType) type).setName(eventName);
    }
    Map<String, TmfEventField> fieldMap = new LinkedHashMap<>();
    for (OutputColumn outputColumn : fDefinition.outputs) {
        if (outputColumn.tag.equals(Tag.TIMESTAMP)) {
            if (timestamp != null && fDefinition.timeStampOutputFormat != null && !fDefinition.timeStampOutputFormat.isEmpty()) {
                TmfTimestampFormat timestampFormat = new TmfTimestampFormat(fDefinition.timeStampOutputFormat);
                fieldMap.put(outputColumn.name, new TmfEventField(outputColumn.name, timestampFormat.format(timestamp.getValue()), null));
            }
        } else if (outputColumn.tag.equals(Tag.OTHER) || outputColumn.tag.equals(Tag.MESSAGE)) {
            Object key = (outputColumn.tag.equals(Tag.OTHER) ? outputColumn.name : outputColumn.tag);
            fieldMap.put(outputColumn.name, new TmfEventField(outputColumn.name, nullToEmptyString(fData.remove(key)), null));
        }
    }
    // This event contains extra values, we process them now
    for (Entry<Object, String> entry : fData.entrySet()) {
        String fieldName = nullToEmptyString(entry.getKey().toString());
        // Ignore extra fields if a field of same name is already set
        if (!fieldMap.containsKey(fieldName)) {
            fieldMap.put(fieldName, new CustomExtraField(fieldName, nullToEmptyString(entry.getValue()), null));
        }
    }
    setContent(new CustomEventContent(customEventContent.getName(), customEventContent.getValue(), fieldMap.values().toArray(new ITmfEventField[fieldMap.size()])));
    fData = null;
}

Example 5 with ITmfEventType

use of org.eclipse.tracecompass.tmf.core.event.ITmfEventType in project tracecompass by tracecompass.

the class CtfTmfEventTest method testGetters.

/**
 * Test the getters for the reference, source and type.
 */
@Test
public void testGetters() {
    long rank = fixture.getRank();
    CtfTmfTrace trace = fixture.getTrace();
    assertEquals("kernel", trace.getName());
    String reference = fixture.getChannel();
    int cpu = fixture.getCPU();
    ITmfEventType type = fixture.getType();
    assertEquals(ITmfContext.UNKNOWN_RANK, rank);
    assertEquals("channel0_1", reference);
    assertEquals(1, cpu);
    assertEquals("exit_syscall", type.toString());
}