diff options
Diffstat (limited to 'tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/trace/text/TextTraceEventContent.java')
| -rw-r--r-- | tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/trace/text/TextTraceEventContent.java | 348 |
1 files changed, 348 insertions, 0 deletions
diff --git a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/trace/text/TextTraceEventContent.java b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/trace/text/TextTraceEventContent.java new file mode 100644 index 0000000000..aab941d4fe --- /dev/null +++ b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/trace/text/TextTraceEventContent.java @@ -0,0 +1,348 @@ +/******************************************************************************* + * Copyright (c) 2012, 2015 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: + * Patrick Tasse - Initial API and implementation + * Bernd Hufmann - Updated equals, clone and hashCode to consider StringBuffer values + *******************************************************************************/ + +package org.eclipse.tracecompass.tmf.core.trace.text; + +import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.jdt.annotation.Nullable; +import org.eclipse.tracecompass.tmf.core.event.ITmfEventField; + +/** + * Implementation of ITmfEventField for Text Traces. + */ +public class TextTraceEventContent implements ITmfEventField { + + private final @NonNull String fName; + private final @NonNull List<TextTraceEventContent> fFields; + + private @Nullable Object fValue; + + // ------------------------------------------------------------------------ + // Constructors + // ------------------------------------------------------------------------ + + /** + * Constructor for a root event content. Subfields with the specified field + * names are created and initialized with a null value. + * + * @param fieldNames + * the array of non-null field names + * @throws IllegalArgumentException + * if any one of the field names is null + */ + public TextTraceEventContent(@NonNull String[] fieldNames) { + fName = ITmfEventField.ROOT_FIELD_ID; + fValue = null; + fFields = new ArrayList<>(fieldNames.length); + for (String fieldName : fieldNames) { + if (fieldName == null) { + throw new IllegalArgumentException("Null field name not allowed"); //$NON-NLS-1$ + } + fFields.add(new TextTraceEventContent(fieldName)); + } + } + + /** + * Constructor for an initial capacity. This should be the expected number + * of fields. + * + * @param initialCapacity + * the initial capacity of the field list + * @since 1.0 + */ + public TextTraceEventContent(int initialCapacity) { + fName = ITmfEventField.ROOT_FIELD_ID; + fValue = null; + fFields = new ArrayList<>(initialCapacity); + } + + /** + * Constructor for a subfield + * + * @param fieldName + * the subfield name + */ + private TextTraceEventContent(@NonNull String fieldName) { + fName = fieldName; + fValue = null; + fFields = checkNotNull(Collections.EMPTY_LIST); + } + + // ------------------------------------------------------------------------ + // ITmfEventField + // ------------------------------------------------------------------------ + + @Override + public String getName() { + return fName; + } + + @Override + public Object getValue() { + return fValue; + } + + @Override + public List<String> getFieldNames() { + List<String> fieldNames = new ArrayList<>(fFields.size()); + for (TextTraceEventContent field : fFields) { + fieldNames.add(field.getName()); + } + return fieldNames; + } + + @Override + public List<TextTraceEventContent> getFields() { + return new ArrayList<>(fFields); + } + + @Override + public ITmfEventField getField(String... path) { + if (path.length == 0) { + return this; + } + // There are no sub fields + if (path.length == 1) { + for (TextTraceEventContent field : fFields) { + if (field.getName().equals(path[0])) { + return field; + } + } + } + return null; + } + + @Override + public String getFormattedValue() { + Object value = fValue; + if (value == null) { + return null; + } + return value.toString(); + } + + // ------------------------------------------------------------------------ + // Convenience getters and setters + // ------------------------------------------------------------------------ + + /** + * Get a field name by index. + * + * @param index + * The index of the field + * @return The name of the field at that index + */ + public String getFieldName(int index) { + if (index >= 0 && index < fFields.size()) { + return fFields.get(index).getName(); + } + return null; + } + + /** + * Get a field by index. + * + * @param index + * The index of the field + * @return The field object at the requested index + */ + public ITmfEventField getField(int index) { + if (index >= 0 && index < fFields.size()) { + return fFields.get(index); + } + return null; + } + + /** + * Get a subfield value by name. + * + * @param name + * a subfield name + * @return field value object + */ + public Object getFieldValue(@NonNull String name) { + for (int i = 0; i < fFields.size(); i++) { + if (fFields.get(i).getName().equals(name)) { + return fFields.get(i).getValue(); + } + } + return null; + } + + /** + * Get a subfield value by index. + * + * @param index + * a subfield index + * @return field value object + */ + public Object getFieldValue(int index) { + if (index >= 0 && index < fFields.size()) { + return fFields.get(index).getValue(); + } + return null; + } + + /** + * Set the content value. + * + * @param value + * the content value + */ + public void setValue(Object value) { + fValue = value; + } + + /** + * Set a subfield value by name. Adds the subfield if it is new. + * + * @param name + * a subfield name + * @param value + * the subfield value + */ + public void setFieldValue(@NonNull String name, Object value) { + TextTraceEventContent field = null; + for (int i = 0; i < fFields.size(); i++) { + if (fFields.get(i).getName().equals(name)) { + field = fFields.get(i); + field.setValue(value); + } + } + if (field == null) { + field = new TextTraceEventContent(name); + field.setValue(value); + fFields.add(field); + } + } + + /** + * Set a subfield value by index. + * + * @param index + * a subfield index + * @param value + * the subfield value + */ + public void setFieldValue(int index, Object value) { + if (index >= 0 && index < fFields.size()) { + fFields.get(index).fValue = value; + } + } + + /** + * Add a new subfield unconditionally and set its value. Note: This can + * create a duplicate subfield. If the subfield already exists, use + * {@link #setFieldValue(String, Object)} instead. + * + * @param name + * a subfield name + * @param value + * the subfield value + * @since 1.0 + */ + public void addField(@NonNull String name, Object value) { + TextTraceEventContent field = new TextTraceEventContent(name); + field.setValue(value); + fFields.add(field); + } + + // ------------------------------------------------------------------------ + // Object + // ------------------------------------------------------------------------ + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + fFields.hashCode(); + result = prime * result + fName.hashCode(); + int tmpHash = 0; // initialize for fValue equals null; + Object value = fValue; + if (value != null) { + if (value instanceof StringBuffer) { + tmpHash = value.toString().hashCode(); + } else { + tmpHash = value.hashCode(); + } + } + result = prime * result + tmpHash; + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + TextTraceEventContent other = (TextTraceEventContent) obj; + if (!fFields.equals(other.fFields)) { + return false; + } + if (!fName.equals(other.fName)) { + return false; + } + + Object value = fValue; + if (value == null) { + if (other.fValue != null) { + return false; + } + } else { + if ((value instanceof StringBuffer) && (other.fValue instanceof StringBuffer)) { + Object otherValue = other.getValue(); + if (otherValue == null) { + return false; + } + if (!value.toString().equals(otherValue.toString())) { + return false; + } + } else if (!value.equals(other.fValue)) { + return false; + } + } + return true; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + if (fName == ITmfEventField.ROOT_FIELD_ID) { + for (int i = 0; i < getFields().size(); i++) { + ITmfEventField field = getFields().get(i); + if (i != 0) { + sb.append(", "); //$NON-NLS-1$ + } + sb.append(field.toString()); + } + } else { + sb.append(fName); + sb.append('='); + sb.append(fValue); + } + return sb.toString(); + } + +} |