}
@Override
- public Iterable<ITmfEventAspect> getEventAspects() {
+ public Iterable<ITmfEventAspect<?>> getEventAspects() {
/*
* This method needs to fill the aspects dynamically because aspects in
* the parent class are not all present at the beginning of the trace
*/
- ImmutableSet.Builder<ITmfEventAspect> builder = ImmutableSet.builder();
+ ImmutableSet.Builder<ITmfEventAspect<?>> builder = ImmutableSet.builder();
builder.addAll(super.getEventAspects());
builder.add(KernelTidAspect.INSTANCE);
builder.add(ThreadPriorityAspect.INSTANCE);
* @author Geneviève Bastien
* @since 1.0
*/
-public abstract class LinuxTidAspect implements ITmfEventAspect {
+public abstract class LinuxTidAspect implements ITmfEventAspect<Integer> {
@Override
public final String getName() {
* @author Christian Mansky
* @since 2.0
*/
-public final class ThreadPriorityAspect implements ITmfEventAspect {
+public final class ThreadPriorityAspect implements ITmfEventAspect<Integer> {
/** The singleton instance */
public static final ThreadPriorityAspect INSTANCE = new ThreadPriorityAspect();
private BtfEventAspects() {}
- private static final Iterable<ITmfEventAspect> BTF_ASPECTS =
+ private static final Iterable<ITmfEventAspect<?>> BTF_ASPECTS =
ImmutableList.of(
ITmfEventAspect.BaseAspects.TIMESTAMP,
new BtfSourceAspect(),
/**
* The "source" aspect, whose value comes from {@link ITmfEvent#getSource()}
*/
- private static class BtfSourceAspect implements ITmfEventAspect {
+ private static class BtfSourceAspect implements ITmfEventAspect<String> {
@Override
public String getName() {
* The "target" aspect, taking its value from
* {@link ITmfEvent#getTarget()}.
*/
- private static class BtfTargetAspect implements ITmfEventAspect {
+ private static class BtfTargetAspect implements ITmfEventAspect<String> {
@Override
public String getName() {
*
* @return The aspects
*/
- public static Iterable<ITmfEventAspect> getAspects() {
+ public static Iterable<ITmfEventAspect<?>> getAspects() {
return BTF_ASPECTS;
}
}
\ No newline at end of file
}
@Override
- public Iterable<ITmfEventAspect> getEventAspects() {
+ public Iterable<ITmfEventAspect<?>> getEventAspects() {
return BtfEventAspects.getAspects();
}
*
* @author Alexandre Montplaisir
*/
-public class CtfChannelAspect implements ITmfEventAspect {
+public class CtfChannelAspect implements ITmfEventAspect<String> {
@Override
public String getName() {
* Event aspects available for all CTF traces
* @since 1.0
*/
- protected static final @NonNull Collection<@NonNull ITmfEventAspect> CTF_ASPECTS =
+ protected static final @NonNull Collection<@NonNull ITmfEventAspect<?>> CTF_ASPECTS =
ImmutableList.of(
ITmfEventAspect.BaseAspects.TIMESTAMP,
new CtfChannelAspect(),
}
@Override
- public Iterable<ITmfEventAspect> getEventAspects() {
+ public Iterable<ITmfEventAspect<?>> getEventAspects() {
return CTF_ASPECTS;
}
private GdbEventAspects() {}
- private static final @NonNull Iterable<ITmfEventAspect> GDB_ASPECTS =
+ private static final @NonNull Iterable<ITmfEventAspect<?>> GDB_ASPECTS =
ImmutableList.of(
new TmfContentFieldAspect(GdbTraceEventContent.TRACE_FRAME, GdbTraceEventContent.TRACE_FRAME),
new TmfContentFieldAspect(GdbTraceEventContent.TRACEPOINT, GdbTraceEventContent.TRACEPOINT),
ITmfEventAspect.BaseAspects.CONTENTS
);
- private static class GdbFileAspect implements ITmfEventAspect {
+ private static class GdbFileAspect implements ITmfEventAspect<String> {
@Override
public String getName() {
*
* @return The set of aspects
*/
- public static @NonNull Iterable<ITmfEventAspect> getAspects() {
+ public static @NonNull Iterable<ITmfEventAspect<?>> getAspects() {
return GDB_ASPECTS;
}
}
// ------------------------------------------------------------------------
@Override
- public Iterable<ITmfEventAspect> getEventAspects() {
+ public Iterable<ITmfEventAspect<?>> getEventAspects() {
return GdbEventAspects.getAspects();
}
/**
* Event aspects available for all Lttng Kernel traces
*/
- private static final @NonNull Collection<ITmfEventAspect> LTTNG_KERNEL_ASPECTS;
+ private static final @NonNull Collection<ITmfEventAspect<?>> LTTNG_KERNEL_ASPECTS;
static {
- ImmutableSet.Builder<ITmfEventAspect> builder = ImmutableSet.builder();
+ ImmutableSet.Builder<ITmfEventAspect<?>> builder = ImmutableSet.builder();
builder.addAll(CtfTmfTrace.CTF_ASPECTS);
builder.add(KernelTidAspect.INSTANCE);
builder.add(ThreadPriorityAspect.INSTANCE);
}
@Override
- public Iterable<ITmfEventAspect> getEventAspects() {
+ public Iterable<ITmfEventAspect<?>> getEventAspects() {
return LTTNG_KERNEL_ASPECTS;
}
* @author Alexandre Montplaisir
* @since 2.0
*/
-public class UstDebugInfoBinaryAspect implements ITmfEventAspect {
+public class UstDebugInfoBinaryAspect implements ITmfEventAspect<BinaryCallsite> {
/** Singleton instance */
public static final UstDebugInfoBinaryAspect INSTANCE = new UstDebugInfoBinaryAspect();
* @author Alexandre Montplaisir
* @since 2.0
*/
-public class UstDebugInfoSourceAspect implements ITmfEventAspect {
+public class UstDebugInfoSourceAspect implements ITmfEventAspect<TmfCallsite> {
/** Singleton instance */
public static final UstDebugInfoSourceAspect INSTANCE = new UstDebugInfoSourceAspect();
private static final int CONFIDENCE = 100;
- private static final @NonNull Collection<ITmfEventAspect> LTTNG_UST_ASPECTS;
+ private static final @NonNull Collection<ITmfEventAspect<?>> LTTNG_UST_ASPECTS;
static {
- ImmutableSet.Builder<ITmfEventAspect> builder = ImmutableSet.builder();
+ ImmutableSet.Builder<ITmfEventAspect<?>> builder = ImmutableSet.builder();
builder.addAll(CtfTmfTrace.CTF_ASPECTS);
builder.add(UstDebugInfoBinaryAspect.INSTANCE);
builder.add(UstDebugInfoSourceAspect.INSTANCE);
}
@Override
- public Iterable<ITmfEventAspect> getEventAspects() {
+ public Iterable<ITmfEventAspect<?>> getEventAspects() {
return LTTNG_UST_ASPECTS;
}
*
* @author Alexandre Montplaisir
*/
-public class PcapDestinationAspect implements ITmfEventAspect {
+public class PcapDestinationAspect implements ITmfEventAspect<String> {
/** Singleton instance */
public static final PcapDestinationAspect INSTANCE = new PcapDestinationAspect();
*
* @author Alexandre Montplaisir
*/
-public class PcapProtocolAspect implements ITmfEventAspect {
+public class PcapProtocolAspect implements ITmfEventAspect<String> {
/** Singleton instance */
public static final PcapProtocolAspect INSTANCE = new PcapProtocolAspect();
*
* @author Alexandre Montplaisir
*/
-public class PcapReferenceAspect implements ITmfEventAspect {
+public class PcapReferenceAspect implements ITmfEventAspect<String> {
/** Singleton instance */
public static final PcapReferenceAspect INSTANCE = new PcapReferenceAspect();
*
* @author Alexandre Montplaisir
*/
-public class PcapSourceAspect implements ITmfEventAspect {
+public class PcapSourceAspect implements ITmfEventAspect<String> {
/** Singleton instance */
public static final PcapSourceAspect INSTANCE = new PcapSourceAspect();
/** pcap trace type id as defined in plugin.xml */
public static final String TRACE_TYPE_ID = "org.eclipse.linuxtools.tmf.pcap.core.pcaptrace"; //$NON-NLS-1$
- private static final Collection<ITmfEventAspect> PCAP_ASPECTS =
+ private static final Collection<ITmfEventAspect<?>> PCAP_ASPECTS =
ImmutableList.of(
ITmfEventAspect.BaseAspects.TIMESTAMP,
PcapSourceAspect.INSTANCE,
}
@Override
- public Iterable<ITmfEventAspect> getEventAspects() {
+ public Iterable<ITmfEventAspect<?>> getEventAspects() {
return PCAP_ASPECTS;
}
*/
@Test
public void testGetEventAspects() {
- Iterable<ITmfEventAspect> aspects = fTrace.getEventAspects();
- for (ITmfEventAspect aspect : aspects) {
+ Iterable<ITmfEventAspect<?>> aspects = fTrace.getEventAspects();
+ for (ITmfEventAspect<?> aspect : aspects) {
assertTrue(TmfTrace.BASE_ASPECTS.contains(aspect));
}
}
private static class TmfTraceStubWithAspects extends TmfTraceStub {
- private static final @NonNull Collection<ITmfEventAspect> EVENT_ASPECTS;
+ private static final @NonNull Collection<ITmfEventAspect<?>> EVENT_ASPECTS;
static {
- ImmutableList.Builder<ITmfEventAspect> builder = ImmutableList.builder();
+ ImmutableList.Builder<ITmfEventAspect<?>> builder = ImmutableList.builder();
builder.add(new TmfCpuAspect() {
@Override
public Integer resolve(ITmfEvent event) {
}
@Override
- public Iterable<ITmfEventAspect> getEventAspects() {
+ public Iterable<ITmfEventAspect<?>> getEventAspects() {
return EVENT_ASPECTS;
}
fail(e1.getMessage());
}
- ITmfEventAspect cpuAspect = null;
- ITmfEventAspect testAspect = null;
+ ITmfEventAspect<?> cpuAspect = null;
+ ITmfEventAspect<?> testAspect = null;
int aspectCount = 0;
- for (ITmfEventAspect aspect : trace.getEventAspects()) {
+ for (ITmfEventAspect<?> aspect : trace.getEventAspects()) {
aspectCount++;
if (aspect instanceof TmfCpuAspect) {
cpuAspect = aspect;
}
/** The event aspects */
- public static final @NonNull Collection<ITmfEventAspect> ASPECTS =
+ public static final @NonNull Collection<ITmfEventAspect<?>> ASPECTS =
ImmutableList.of(
ITmfEventAspect.BaseAspects.TIMESTAMP,
new TmfContentFieldAspect(Field.HOST, Field.HOST),
}
@Override
- public Iterable<ITmfEventAspect> getEventAspects() {
+ public Iterable<ITmfEventAspect<?>> getEventAspects() {
return ASPECTS;
}
}
private final CustomXmlTraceDefinition fDefinition;
private CustomXmlTrace fTrace;
- private Collection<ITmfEventAspect> fAspects = TmfTrace.BASE_ASPECTS;
- private final Collection<ITmfEventAspect> fAdditionalAspects = new HashSet<>();
+ private Collection<ITmfEventAspect<?>> fAspects = TmfTrace.BASE_ASPECTS;
+ private final Collection<ITmfEventAspect<?>> fAdditionalAspects = new HashSet<>();
/**
* Constructor. Constructs the custom XML trace with the appropriate
}
private void generateAspects(ITmfEventField[] fieldsArray) {
- ImmutableList.Builder<ITmfEventAspect> builder = new ImmutableList.Builder<>();
+ ImmutableList.Builder<ITmfEventAspect<?>> builder = new ImmutableList.Builder<>();
/* Initialize the first default trace aspects */
builder.add(ITmfEventAspect.BaseAspects.TIMESTAMP);
/* Add custom aspects in between */
for (ITmfEventField field : fieldsArray) {
String name = field.getName();
- final ITmfEventAspect aspect = new TmfContentFieldAspect(name, name);
+ final ITmfEventAspect<?> aspect = new TmfContentFieldAspect(name, name);
if (name.equals(ASPECT_CPU)) {
builder.add(new TmfCpuAspect() {
@Override
}
@Override
- public Iterable<ITmfEventAspect> getEventAspects() {
+ public Iterable<ITmfEventAspect<?>> getEventAspects() {
return fAspects;
}
* @param aspect
* The aspect to have
*/
- public void addEventAspect(ITmfEventAspect aspect) {
+ public void addEventAspect(ITmfEventAspect<?> aspect) {
fAdditionalAspects.add(aspect);
}
* Aspects for custom events, which use an integer ID to represent each
* field.
*/
- private static final class CustomEventFieldAspect implements ITmfEventAspect {
+ private static final class CustomEventFieldAspect implements ITmfEventAspect<String> {
private final @NonNull String fName;
private final int fIndex;
* want the aspects
* @return The set of event aspects for the given trace
*/
- public static @NonNull Iterable<ITmfEventAspect> generateAspects(CustomTraceDefinition definition) {
- ImmutableList.Builder<ITmfEventAspect> builder = new ImmutableList.Builder<>();
+ public static @NonNull Iterable<ITmfEventAspect<?>> generateAspects(CustomTraceDefinition definition) {
+ ImmutableList.Builder<ITmfEventAspect<?>> builder = new ImmutableList.Builder<>();
List<OutputColumn> outputs = definition.outputs;
for (int i = 0; i < outputs.size(); i++) {
String name = outputs.get(i).name;
* on to only keep certain events, to plot XY charts, etc.
*
* @author Alexandre Montplaisir
+ * @param <T> Type of the return value of the {@link #resolve} method
*/
-public interface ITmfEventAspect {
+public interface ITmfEventAspect<T> {
/**
* Static definition of an empty string. You can use this instead of 'null'!
/**
* List of all common base aspects
*/
- public static final List<ITmfEventAspect> BASE_ASPECTS =
+ public static final List<ITmfEventAspect<?>> BASE_ASPECTS =
ImmutableList.of(
BaseAspects.TIMESTAMP,
BaseAspects.EVENT_TYPE,
/**
* Aspect for the event timestamp
*/
- ITmfEventAspect TIMESTAMP = new ITmfEventAspect() {
+ ITmfEventAspect<ITmfTimestamp> TIMESTAMP = new ITmfEventAspect<ITmfTimestamp>() {
@Override
public String getName() {
return Messages.getMessage(Messages.AspectName_Timestamp);
/**
* Aspect for the event type
*/
- ITmfEventAspect EVENT_TYPE = new ITmfEventAspect() {
+ ITmfEventAspect<String> EVENT_TYPE = new ITmfEventAspect<String>() {
@Override
public String getName() {
return Messages.getMessage(Messages.AspectName_EventType);
/**
* Aspect for the trace's name (for experiments with many traces)
*/
- ITmfEventAspect TRACE_NAME = new ITmfEventAspect() {
+ ITmfEventAspect<String> TRACE_NAME = new ITmfEventAspect<String>() {
@Override
public String getName() {
return Messages.getMessage(Messages.AspectName_TraceName);
* The event to process
* @return The resulting tidbit of information for this event.
*/
- @Nullable Object resolve(ITmfEvent event);
+ @Nullable T resolve(ITmfEvent event);
}
*
* @author Alexandre Montplaisir
*/
-public class TmfContentFieldAspect implements ITmfEventAspect {
+public class TmfContentFieldAspect implements ITmfEventAspect<Object> {
private final String fAspectName;
private final String[] fFieldPath;
*
* @author Alexandre Montplaisir
*/
-public abstract class TmfCpuAspect implements ITmfEventAspect {
+public abstract class TmfCpuAspect implements ITmfEventAspect<Integer> {
@Override
public final String getName() {
*
* @author Patrick Tasse
*/
-public class TmfEventFieldAspect implements ITmfEventAspect {
+public class TmfEventFieldAspect implements ITmfEventAspect<Object> {
private static final char SLASH = '/';
private static final char BACKSLASH = '\\';
*
* @author Alexandre Montplaisir
*/
-public class TmfStateSystemAspect implements ITmfEventAspect {
+public class TmfStateSystemAspect implements ITmfEventAspect<String> {
private final @Nullable String fName;
private final ITmfStateSystem fSS;
public static final String BASE_ASPECT_ID = "BASE.ASPECT.ID"; //$NON-NLS-1$
/** event aspect */
- protected ITmfEventAspect fEventAspect;
+ protected ITmfEventAspect<?> fEventAspect;
private String fTraceTypeId;
/**
* @return The event aspect of this filter
*/
- public ITmfEventAspect getEventAspect() {
+ public ITmfEventAspect<?> getEventAspect() {
return fEventAspect;
}
* @param aspect
* The event aspect to assign to this filter
*/
- public void setEventAspect(ITmfEventAspect aspect) {
+ public void setEventAspect(ITmfEventAspect<?> aspect) {
fEventAspect = aspect;
}
traceTypeId = TmfTraceType.buildCompatibilityTraceTypeId(traceTypeId);
String name = atts.getValue(TmfFilterAspectNode.EVENT_ASPECT_ATTR);
if (TmfFilterAspectNode.BASE_ASPECT_ID.equals(traceTypeId)) {
- for (ITmfEventAspect eventAspect : ITmfEventAspect.BASE_ASPECTS) {
+ for (ITmfEventAspect<?> eventAspect : ITmfEventAspect.BASE_ASPECTS) {
if (eventAspect.getName().equals(name)) {
node.setEventAspect(eventAspect);
node.setTraceTypeId(traceTypeId);
} else if (traceTypeId != null && name != null) {
TraceTypeHelper helper = TmfTraceType.getTraceType(traceTypeId);
if (helper != null) {
- for (ITmfEventAspect eventAspect : helper.getTrace().getEventAspects()) {
+ for (ITmfEventAspect<?> eventAspect : helper.getTrace().getEventAspects()) {
if (eventAspect.getName().equals(name)) {
node.setEventAspect(eventAspect);
node.setTraceTypeId(traceTypeId);
}
@Override
- public Iterable<ITmfEventAspect> getEventAspects() {
+ public Iterable<ITmfEventAspect<?>> getEventAspects() {
return CustomEventAspects.generateAspects(fDefinition);
}
}
@Override
- public Iterable<ITmfEventAspect> getEventAspects() {
+ public Iterable<ITmfEventAspect<?>> getEventAspects() {
return CustomEventAspects.generateAspects(fDefinition);
}
*
* @return The event aspects for this trace
*/
- @NonNull Iterable<@NonNull ITmfEventAspect> getEventAspects();
+ @NonNull Iterable<@NonNull ITmfEventAspect<?>> getEventAspects();
// ------------------------------------------------------------------------
// Trace characteristics getters
/**
* Basic aspects that should be valid for all trace types.
*/
- public static final @NonNull Collection<@NonNull ITmfEventAspect> BASE_ASPECTS =
+ public static final @NonNull Collection<@NonNull ITmfEventAspect<?>> BASE_ASPECTS =
ImmutableList.of(
ITmfEventAspect.BaseAspects.TIMESTAMP,
ITmfEventAspect.BaseAspects.EVENT_TYPE,
}
@Override
- public Iterable<ITmfEventAspect> getEventAspects() {
+ public Iterable<ITmfEventAspect<?>> getEventAspects() {
/* By default we provide only the base aspects valid for all trace types */
return BASE_ASPECTS;
}
* {@link ITmfEventAspect#resolve(ITmfEvent)} that returns non null
* for the event or {@code null} otherwise
*/
- public static @Nullable <T extends ITmfEventAspect> Object resolveEventAspectOfClassForEvent(
+ public static @Nullable <T extends ITmfEventAspect<?>> Object resolveEventAspectOfClassForEvent(
ITmfTrace trace, Class<T> aspectClass, ITmfEvent event) {
- Iterable<ITmfEventAspect> aspects = trace.getEventAspects();
- for (ITmfEventAspect aspect : aspects) {
+ Iterable<ITmfEventAspect<?>> aspects = trace.getEventAspects();
+ for (ITmfEventAspect<?> aspect : aspects) {
if (aspectClass.isAssignableFrom(aspect.getClass())) {
Object obj = aspect.resolve(event);
if (obj != null) {
* for the event or {@code null} otherwise
* @since 2.0
*/
- public static @Nullable <T extends ITmfEventAspect> Integer resolveIntEventAspectOfClassForEvent(
+ public static @Nullable <T extends ITmfEventAspect<Integer>> Integer resolveIntEventAspectOfClassForEvent(
ITmfTrace trace, Class<T> aspectClass, ITmfEvent event) {
Object result = resolveEventAspectOfClassForEvent(trace, aspectClass, event);
if (result instanceof Integer) {
* Use the aspects defined by the trace type (or each trace type in an
* experiment) to build a table consisting of these.
*/
- Iterable<ITmfEventAspect> aspects = getTraceAspects(trace);
+ Iterable<ITmfEventAspect<?>> aspects = getTraceAspects(trace);
if (Iterables.isEmpty(aspects)) {
/* Couldn't find any event aspects, use a default table */
return new TmfEventsTable(parent, cacheSize);
* The cache size to use
* @return The event table for the trace
*/
- private static @NonNull Iterable<ITmfEventAspect> getTraceAspects(ITmfTrace trace) {
+ private static @NonNull Iterable<ITmfEventAspect<?>> getTraceAspects(ITmfTrace trace) {
if (trace instanceof TmfExperiment) {
return getExperimentAspects((TmfExperiment) trace);
}
* the event table cache size
* @return An event table of the appropriate type
*/
- private static @NonNull Iterable<ITmfEventAspect> getExperimentAspects(
+ private static @NonNull Iterable<ITmfEventAspect<?>> getExperimentAspects(
final TmfExperiment experiment) {
List<ITmfTrace> traces = experiment.getTraces();
- ImmutableSet.Builder<ITmfEventAspect> builder = new ImmutableSet.Builder<>();
+ ImmutableSet.Builder<ITmfEventAspect<?>> builder = new ImmutableSet.Builder<>();
/* For experiments, we'll add a "trace name" aspect/column */
builder.add(ITmfEventAspect.BaseAspects.TRACE_NAME);
* trace types.
*/
for (ITmfTrace trace : traces) {
- Iterable<ITmfEventAspect> traceAspects = trace.getEventAspects();
+ Iterable<ITmfEventAspect<?>> traceAspects = trace.getEventAspects();
builder.addAll(traceAspects);
}
}
}
@Deprecated
- private static @NonNull Iterable<ITmfEventAspect> convertFromColumnData(
+ private static @NonNull Iterable<ITmfEventAspect<?>> convertFromColumnData(
org.eclipse.tracecompass.tmf.ui.widgets.virtualtable.ColumnData[] columnData) {
- ImmutableList.Builder<ITmfEventAspect> builder = new ImmutableList.Builder<>();
+ ImmutableList.Builder<ITmfEventAspect<?>> builder = new ImmutableList.Builder<>();
for (org.eclipse.tracecompass.tmf.ui.widgets.virtualtable.ColumnData col : columnData) {
String fieldName = col.header;
if (fieldName != null) {
* </p>
*/
public TmfEventsTable(final Composite parent, int cacheSize,
- @NonNull Iterable<ITmfEventAspect> aspects) {
+ @NonNull Iterable<ITmfEventAspect<?>> aspects) {
super("TmfEventsTable"); //$NON-NLS-1$
fComposite = new Composite(parent, SWT.NONE);
fTable.setLinesVisible(true);
// Setup the columns
- for (ITmfEventAspect aspect : aspects) {
+ for (ITmfEventAspect<?> aspect : aspects) {
if (aspect != null) {
fColumns.add(new TmfEventTableColumn(aspect));
}
return false;
}
final TmfFilterMatchesNode filter = new TmfFilterMatchesNode(null);
- ITmfEventAspect aspect = (ITmfEventAspect) column.getData(Key.ASPECT);
+ ITmfEventAspect<?> aspect = (ITmfEventAspect<?>) column.getData(Key.ASPECT);
filter.setEventAspect(aspect);
filter.setRegex(regex);
column.setData(Key.SEARCH_OBJ, filter);
*/
private static final class TmfMarginColumn extends TmfEventTableColumn {
- private static final @NonNull ITmfEventAspect MARGIN_ASPECT = new ITmfEventAspect() {
+ private static final @NonNull ITmfEventAspect<String> MARGIN_ASPECT =
+ new ITmfEventAspect<String>() {
@Override
public String getName() {
// Fields
// ------------------------------------------------------------------------
- private final ITmfEventAspect fAspect;
+ private final ITmfEventAspect<?> fAspect;
// ------------------------------------------------------------------------
// Constructors
* The {@link ITmfEventAspect} to be used to populate this
* column.
*/
- public TmfEventTableColumn(ITmfEventAspect aspect) {
+ public TmfEventTableColumn(ITmfEventAspect<?> aspect) {
fAspect = aspect;
}
*
* @return The event aspect
*/
- public ITmfEventAspect getEventAspect() {
+ public ITmfEventAspect<?> getEventAspect() {
return fAspect;
}
private static class AspectItem {
public String label;
- public ITmfEventAspect eventAspect;
+ public ITmfEventAspect<?> eventAspect;
public String traceTypeId;
public AspectItem(String label) {
this.label = label;
}
- public AspectItem(String label, ITmfEventAspect eventAspect, String traceTypeId) {
+ public AspectItem(String label, ITmfEventAspect<?> eventAspect, String traceTypeId) {
this.label = label;
this.eventAspect = eventAspect;
this.traceTypeId = traceTypeId;
ArrayList<AspectItem> aspectList = new ArrayList<>();
aspectList.add(new AspectItem(Messages.FilterViewer_CommonCategory));
- for (ITmfEventAspect aspect : ITmfEventAspect.BASE_ASPECTS) {
+ for (ITmfEventAspect<?> aspect : ITmfEventAspect.BASE_ASPECTS) {
aspectList.add(new AspectItem(aspect.getName(), aspect, TmfFilterAspectNode.BASE_ASPECT_ID));
}
if (helper != null) {
aspectList.add(new AspectItem("")); //$NON-NLS-1$
aspectList.add(new AspectItem('[' + helper.getLabel() + ']'));
- for (ITmfEventAspect aspect : helper.getTrace().getEventAspects()) {
+ for (ITmfEventAspect<?> aspect : helper.getTrace().getEventAspects()) {
for (AspectItem baseAspect : aspectList) {
if (aspect.equals(baseAspect.eventAspect)) {
aspectList.remove(baseAspect);
projects / deliverable / tracecompass.git / commitdiff
