<?xml version="1.0" encoding="UTF-8"?>
<classpath>
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="src" path="src"/>
<classpathentry kind="output" path="bin"/>
org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable
org.eclipse.jdt.core.compiler.annotation.nullanalysis=enabled
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.compliance=1.7
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.discouragedReference=warning
org.eclipse.jdt.core.compiler.problem.emptyStatement=warning
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=warning
+org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=error
org.eclipse.jdt.core.compiler.problem.fallthroughCase=warning
org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled
org.eclipse.jdt.core.compiler.problem.fieldHiding=warning
org.eclipse.jdt.core.compiler.problem.rawTypeReference=warning
org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning
org.eclipse.jdt.core.compiler.problem.redundantNullCheck=warning
-org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=warning
+org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=error
org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=warning
org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore
org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=warning
org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.7
org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
Bundle-Localization: plugin
Bundle-SymbolicName: org.eclipse.linuxtools.lttng.alltests;singleton:=true
Bundle-ActivationPolicy: lazy
-Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
Require-Bundle: org.junit;bundle-version="4.0.0",
org.eclipse.linuxtools.ctf.core.tests;bundle-version="2.1.0",
org.eclipse.linuxtools.gdbtrace.core.tests;bundle-version="1.1.0",
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="src" path="src"/>
<classpathentry kind="output" path="bin"/>
org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable
org.eclipse.jdt.core.compiler.annotation.nullanalysis=enabled
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.compliance=1.7
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.discouragedReference=error
org.eclipse.jdt.core.compiler.problem.emptyStatement=error
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=warning
+org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=error
org.eclipse.jdt.core.compiler.problem.fallthroughCase=error
org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled
org.eclipse.jdt.core.compiler.problem.fieldHiding=error
org.eclipse.jdt.core.compiler.problem.rawTypeReference=error
org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning
org.eclipse.jdt.core.compiler.problem.redundantNullCheck=error
-org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=warning
+org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=error
org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=error
org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore
org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=error
org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedWarningToken=error
org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=error
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.7
org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
Bundle-Localization: plugin
Bundle-SymbolicName: org.eclipse.linuxtools.lttng2.core.tests;singleton:=true
Bundle-ActivationPolicy: lazy
-Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
Require-Bundle: org.junit;bundle-version="4.0.0",
org.eclipse.core.runtime,
org.eclipse.linuxtools.lttng2.core;bundle-version="3.0.0"
IFieldInfo field2 = new FieldInfo("stringfield");
field2.setFieldType("string");
- List<IFieldInfo> fields = new LinkedList<IFieldInfo>();
+ List<IFieldInfo> fields = new LinkedList<>();
fields.add(field1);
fields.add(field2);
info.setFields(fields);
fixture.setNumberOfSubBuffers(1);
fixture.setOutputType("");
fixture.setSubBufferSize(1L);
- List<IEventInfo> events = new LinkedList<IEventInfo>();
+ List<IEventInfo> events = new LinkedList<>();
for (int i = 0; i < 2; i++) {
IEventInfo info = new EventInfo("event" + i);
assertEquals(fChannelInfo1, fDomainInfo1.getChannels()[0]);
IDomainInfo domain = new DomainInfo("domain");
- List<IChannelInfo> list = new LinkedList<IChannelInfo>();
+ List<IChannelInfo> list = new LinkedList<>();
list.add(fChannelInfo1);
list.add(fChannelInfo2);
domain.setChannels(list);
assertEquals(fDomainInfo1, fSessionInfo1.getDomains()[0]);
ISessionInfo session = new SessionInfo("session");
- List<IDomainInfo> list = new LinkedList<IDomainInfo>();
+ List<IDomainInfo> list = new LinkedList<>();
list.add(fDomainInfo1);
list.add(fDomainInfo2);
session.setDomains(list);
public void testSetEvents_1() {
UstProviderInfo fixture = new UstProviderInfo("test");
fixture.setPid(2468);
- List<IBaseEventInfo> events = new LinkedList<IBaseEventInfo>();
+ List<IBaseEventInfo> events = new LinkedList<>();
events.add(fEventInfo1);
events.add(fEventInfo2);
fixture.setEvents(events);
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="src" path="src"/>
<classpathentry kind="output" path="bin"/>
org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable
org.eclipse.jdt.core.compiler.annotation.nullanalysis=enabled
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.compliance=1.7
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.discouragedReference=error
org.eclipse.jdt.core.compiler.problem.emptyStatement=error
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=warning
+org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=error
org.eclipse.jdt.core.compiler.problem.fallthroughCase=error
org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled
org.eclipse.jdt.core.compiler.problem.fieldHiding=error
org.eclipse.jdt.core.compiler.problem.rawTypeReference=error
org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning
org.eclipse.jdt.core.compiler.problem.redundantNullCheck=error
-org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=warning
+org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=error
org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=error
org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore
org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=error
org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedWarningToken=error
org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=error
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.7
org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
Bundle-SymbolicName: org.eclipse.linuxtools.lttng2.core;singleton:=true
Bundle-Activator: org.eclipse.linuxtools.internal.lttng2.core.Activator
Bundle-ActivationPolicy: lazy
-Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
Require-Bundle: org.eclipse.core.runtime
Export-Package: org.eclipse.linuxtools.internal.lttng2.core;x-friends:="org.eclipse.linuxtools.lttng2.core.tests",
org.eclipse.linuxtools.internal.lttng2.core.control.model;x-friends:="org.eclipse.linuxtools.lttng2.ui,org.eclipse.linuxtools.lttng2.ui.tests,org.eclipse.linuxtools.lttng2.core.tests",
/**
* The Event fields
*/
- private final List<IFieldInfo> fFields = new ArrayList<IFieldInfo>();
+ private final List<IFieldInfo> fFields = new ArrayList<>();
/**
* The filter expression.
*/
/**
* The events information of the channel.
*/
- private final List<IEventInfo> fEvents = new ArrayList<IEventInfo>();
+ private final List<IEventInfo> fEvents = new ArrayList<>();
/**
* The maximum size of trace files
*/
/**
* The channels information of the domain.
*/
- private final List<IChannelInfo> fChannels = new ArrayList<IChannelInfo>();
+ private final List<IChannelInfo> fChannels = new ArrayList<>();
private boolean fIsKernel = false;
private BufferType fBufferType = BufferType.BUFFER_TYPE_UNKNOWN;
/**
* The domains information of this session.
*/
- private final List<IDomainInfo> fDomains = new ArrayList<IDomainInfo>();
+ private final List<IDomainInfo> fDomains = new ArrayList<>();
/**
* Flag to indicate whether trace is streamed over network or not.
*/
/**
* List of event information.
*/
- private final List<IBaseEventInfo> fEvents = new ArrayList<IBaseEventInfo>();
+ private final List<IBaseEventInfo> fEvents = new ArrayList<>();
// ------------------------------------------------------------------------
// Constructors
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="src" path="src"/>
<classpathentry kind="output" path="bin"/>
org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable
org.eclipse.jdt.core.compiler.annotation.nullanalysis=enabled
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.compliance=1.7
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.discouragedReference=error
org.eclipse.jdt.core.compiler.problem.emptyStatement=error
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=warning
+org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=error
org.eclipse.jdt.core.compiler.problem.fallthroughCase=error
org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled
org.eclipse.jdt.core.compiler.problem.fieldHiding=error
org.eclipse.jdt.core.compiler.problem.rawTypeReference=error
org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning
org.eclipse.jdt.core.compiler.problem.redundantNullCheck=error
-org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=warning
+org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=error
org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=error
org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore
org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=error
org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedWarningToken=error
org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=error
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.7
org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
Bundle-Localization: plugin
Bundle-SymbolicName: org.eclipse.linuxtools.lttng2.kernel.core.tests;singleton:=true
Bundle-ActivationPolicy: lazy
-Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
Require-Bundle: org.junit;bundle-version="4.0.0",
org.eclipse.core.runtime,
org.eclipse.linuxtools.tmf.core;bundle-version="3.0.0",
File stateFile = File.createTempFile("test-values", ".ht");
stateFile.deleteOnExit();
File logFile = File.createTempFile("TestValues", ".java");
- PrintWriter writer = new PrintWriter(new FileWriter(logFile), true);
-
- /* Build and query the state system */
- ITmfStateProvider input = new LttngKernelStateProvider(testTrace.getTrace());
- ITmfStateSystem ssq = TmfStateSystemFactory.newFullHistory(stateFile, input, true);
- List<ITmfStateInterval> fullState = ssq.queryFullState(targetTimestamp);
-
- /* Start printing the java file's contents */
- writer.println("interface TestValues {");
- writer.println();
- writer.println(INDENT + "static final int size = " + fullState.size() +";");
- writer.println();
-
- /* Print the array contents */
- writer.println(INDENT + "static final long[] startTimes = {");
- for (ITmfStateInterval interval : fullState) {
- writer.println(INDENT + INDENT + String.valueOf(interval.getStartTime()) + "L,");
- }
- writer.println(INDENT + "};");
- writer.println();
+ try (PrintWriter writer = new PrintWriter(new FileWriter(logFile), true);) {
+
+ /* Build and query the state system */
+ ITmfStateProvider input = new LttngKernelStateProvider(testTrace.getTrace());
+ ITmfStateSystem ssq = TmfStateSystemFactory.newFullHistory(stateFile, input, true);
+ List<ITmfStateInterval> fullState = ssq.queryFullState(targetTimestamp);
+
+ /* Start printing the java file's contents */
+ writer.println("interface TestValues {");
+ writer.println();
+ writer.println(INDENT + "static final int size = " + fullState.size() + ";");
+ writer.println();
+
+ /* Print the array contents */
+ writer.println(INDENT + "static final long[] startTimes = {");
+ for (ITmfStateInterval interval : fullState) {
+ writer.println(INDENT + INDENT + String.valueOf(interval.getStartTime()) + "L,");
+ }
+ writer.println(INDENT + "};");
+ writer.println();
- writer.println(INDENT + "static final long[] endTimes = {");
- for (ITmfStateInterval interval : fullState) {
- writer.println(INDENT + INDENT + String.valueOf(interval.getEndTime())+ "L,");
- }
- writer.println(INDENT + "};");
- writer.println();
-
- writer.println(INDENT + "static final ITmfStateValue[] values = {");
- for (ITmfStateInterval interval : fullState) {
- ITmfStateValue val = interval.getStateValue();
- writer.print(INDENT + INDENT);
-
- switch (val.getType()) {
- case NULL:
- writer.println("TmfStateValue.nullValue(),");
- break;
- case INTEGER:
- writer.println("TmfStateValue.newValueInt(" + val.unboxInt() + "),");
- break;
- case LONG:
- writer.println("TmfStateValue.newValueLong(" + val.unboxLong() +"),");
- break;
- case DOUBLE:
- writer.println("TmfStateValue.newValueDouble(" + val.unboxDouble() +"),");
- break;
- case STRING:
- writer.println("TmfStateValue.newValueString(\"" + val.unboxStr() + "\"),");
- break;
- default:
- writer.println(val.toString());
- break;
+ writer.println(INDENT + "static final long[] endTimes = {");
+ for (ITmfStateInterval interval : fullState) {
+ writer.println(INDENT + INDENT + String.valueOf(interval.getEndTime()) + "L,");
}
- }
- writer.println(INDENT + "};");
+ writer.println(INDENT + "};");
+ writer.println();
+
+ writer.println(INDENT + "static final ITmfStateValue[] values = {");
+ for (ITmfStateInterval interval : fullState) {
+ ITmfStateValue val = interval.getStateValue();
+ writer.print(INDENT + INDENT);
+
+ switch (val.getType()) {
+ case NULL:
+ writer.println("TmfStateValue.nullValue(),");
+ break;
+ case INTEGER:
+ writer.println("TmfStateValue.newValueInt(" + val.unboxInt() + "),");
+ break;
+ case LONG:
+ writer.println("TmfStateValue.newValueLong(" + val.unboxLong() + "),");
+ break;
+ case DOUBLE:
+ writer.println("TmfStateValue.newValueDouble(" + val.unboxDouble() + "),");
+ break;
+ case STRING:
+ writer.println("TmfStateValue.newValueString(\"" + val.unboxStr() + "\"),");
+ break;
+ default:
+ writer.println(val.toString());
+ break;
+ }
+ }
+ writer.println(INDENT + "};");
- writer.println("}");
- writer.println();
+ writer.println("}");
+ writer.println();
- writer.close();
+ }
System.exit(0);
}
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="src" path="src"/>
<classpathentry kind="output" path="bin"/>
org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable
org.eclipse.jdt.core.compiler.annotation.nullanalysis=enabled
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.compliance=1.7
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.discouragedReference=error
org.eclipse.jdt.core.compiler.problem.emptyStatement=warning
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=warning
+org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=error
org.eclipse.jdt.core.compiler.problem.fallthroughCase=error
org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled
org.eclipse.jdt.core.compiler.problem.fieldHiding=error
org.eclipse.jdt.core.compiler.problem.rawTypeReference=error
org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning
org.eclipse.jdt.core.compiler.problem.redundantNullCheck=error
-org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=warning
+org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=error
org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=error
org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore
org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=error
org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedWarningToken=error
org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.7
org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
Bundle-SymbolicName: org.eclipse.linuxtools.lttng2.kernel.core;singleton:=true
Bundle-Activator: org.eclipse.linuxtools.internal.lttng2.kernel.core.Activator
Bundle-ActivationPolicy: lazy
-Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
Require-Bundle: org.eclipse.core.runtime,
org.eclipse.core.resources,
org.eclipse.linuxtools.ctf.core;bundle-version="3.0.0",
* TODO Replace with straight strings in the switch/case once we move to
* Java 7
*/
- HashMap<String, Integer> map = new HashMap<String, Integer>();
+ HashMap<String, Integer> map = new HashMap<>();
map.put(LttngStrings.EXIT_SYSCALL, 1);
map.put(LttngStrings.IRQ_HANDLER_ENTRY, 2);
*/
@Override
public List<Object> getUniqueField(ITmfEvent event) {
- List<Object> keys = new ArrayList<Object>();
+ List<Object> keys = new ArrayList<>();
keys.add(event.getContent().getField(TcpEventStrings.SEQ).getValue());
keys.add(event.getContent().getField(TcpEventStrings.ACKSEQ).getValue());
*/
@Override
public List<Object> getUniqueField(ITmfEvent event) {
- List<Object> keys = new ArrayList<Object>();
+ List<Object> keys = new ArrayList<>();
TmfEventField field = (TmfEventField) event.getContent();
ITmfEventField data;
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="src" path="src"/>
<classpathentry kind="output" path="bin"/>
org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable
org.eclipse.jdt.core.compiler.annotation.nullanalysis=enabled
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.compliance=1.7
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.discouragedReference=error
org.eclipse.jdt.core.compiler.problem.emptyStatement=error
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=warning
+org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=error
org.eclipse.jdt.core.compiler.problem.fallthroughCase=error
org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled
org.eclipse.jdt.core.compiler.problem.fieldHiding=error
org.eclipse.jdt.core.compiler.problem.rawTypeReference=error
org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning
org.eclipse.jdt.core.compiler.problem.redundantNullCheck=error
-org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=warning
+org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=error
org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=error
org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore
org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=error
org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedWarningToken=error
org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=error
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.7
org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
Bundle-Localization: plugin
Bundle-SymbolicName: org.eclipse.linuxtools.lttng2.kernel.ui.tests;singleton:=true
Bundle-ActivationPolicy: lazy
-Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
Require-Bundle: org.junit;bundle-version="4.0.0",
org.eclipse.core.runtime,
org.eclipse.ui,
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="src" path="src"/>
<classpathentry kind="output" path="bin"/>
org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable
org.eclipse.jdt.core.compiler.annotation.nullanalysis=enabled
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.compliance=1.7
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.discouragedReference=error
org.eclipse.jdt.core.compiler.problem.emptyStatement=error
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=warning
+org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=error
org.eclipse.jdt.core.compiler.problem.fallthroughCase=error
org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled
org.eclipse.jdt.core.compiler.problem.fieldHiding=error
org.eclipse.jdt.core.compiler.problem.rawTypeReference=error
org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning
org.eclipse.jdt.core.compiler.problem.redundantNullCheck=error
-org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=warning
+org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=error
org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=error
org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore
org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=error
org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedWarningToken=error
org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=error
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.7
org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
Bundle-SymbolicName: org.eclipse.linuxtools.lttng2.kernel.ui;singleton:=true
Bundle-Activator: org.eclipse.linuxtools.internal.lttng2.kernel.ui.Activator
Bundle-ActivationPolicy: lazy
-Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
Require-Bundle: org.eclipse.ui,
org.eclipse.ui.ide,
org.eclipse.core.resources,
@Override
public Map<String, String> getEventHoverToolTipInfo(ITimeEvent event) {
- Map<String, String> retMap = new LinkedHashMap<String, String>();
+ Map<String, String> retMap = new LinkedHashMap<>();
if (!(event instanceof TimeEvent) || !((TimeEvent) event).hasValue() ||
!(event.getEntry() instanceof ControlFlowEntry)) {
return retMap;
setStartTime(Long.MAX_VALUE);
setEndTime(Long.MIN_VALUE);
- ArrayList<ControlFlowEntry> rootList = new ArrayList<ControlFlowEntry>();
+ ArrayList<ControlFlowEntry> rootList = new ArrayList<>();
for (ITmfTrace aTrace : TmfTraceManager.getTraceSet(trace)) {
if (monitor.isCanceled()) {
return;
}
if (aTrace instanceof LttngKernelTrace) {
- ArrayList<ControlFlowEntry> entryList = new ArrayList<ControlFlowEntry>();
+ ArrayList<ControlFlowEntry> entryList = new ArrayList<>();
LttngKernelTrace ctfKernelTrace = (LttngKernelTrace) aTrace;
ITmfStateSystem ssq = ctfKernelTrace.getStateSystems().get(LttngKernelTrace.STATE_ID);
if (!ssq.waitUntilBuilt()) {
try {
int statusQuark = ssq.getQuarkRelative(entry.getThreadQuark(), Attributes.STATUS);
List<ITmfStateInterval> statusIntervals = ssq.queryHistoryRange(statusQuark, realStart, realEnd - 1, resolution, monitor);
- eventList = new ArrayList<ITimeEvent>(statusIntervals.size());
+ eventList = new ArrayList<>(statusIntervals.size());
long lastEndTime = -1;
for (ITmfStateInterval statusInterval : statusIntervals) {
if (monitor.isCanceled()) {
@Override
protected List<ILinkEvent> getLinkList(long startTime, long endTime, long resolution, IProgressMonitor monitor) {
- List<ILinkEvent> list = new ArrayList<ILinkEvent>();
+ List<ILinkEvent> list = new ArrayList<>();
ITmfTrace[] traces = TmfTraceManager.getTraceSet(getTrace());
List<TimeGraphEntry> entryList = getEntryListMap().get(getTrace());
if (traces == null || entryList == null) {
@Override
public Map<String, String> getEventHoverToolTipInfo(ITimeEvent event, long hoverTime) {
- Map<String, String> retMap = new LinkedHashMap<String, String>();
+ Map<String, String> retMap = new LinkedHashMap<>();
if (event instanceof TimeEvent && ((TimeEvent) event).hasValue()) {
TimeEvent tcEvent = (TimeEvent) event;
setStartTime(Long.MAX_VALUE);
setEndTime(Long.MIN_VALUE);
- ArrayList<ResourcesEntry> entryList = new ArrayList<ResourcesEntry>();
+ ArrayList<ResourcesEntry> entryList = new ArrayList<>();
for (ITmfTrace aTrace : TmfTraceManager.getTraceSet(trace)) {
if (monitor.isCanceled()) {
return;
if (resourcesEntry.getType().equals(Type.CPU)) {
int statusQuark = ssq.getQuarkRelative(quark, Attributes.STATUS);
List<ITmfStateInterval> statusIntervals = ssq.queryHistoryRange(statusQuark, realStart, realEnd - 1, resolution, monitor);
- eventList = new ArrayList<ITimeEvent>(statusIntervals.size());
+ eventList = new ArrayList<>(statusIntervals.size());
long lastEndTime = -1;
for (ITmfStateInterval statusInterval : statusIntervals) {
if (monitor.isCanceled()) {
}
} else if (resourcesEntry.getType().equals(Type.IRQ)) {
List<ITmfStateInterval> irqIntervals = ssq.queryHistoryRange(quark, realStart, realEnd - 1, resolution, monitor);
- eventList = new ArrayList<ITimeEvent>(irqIntervals.size());
+ eventList = new ArrayList<>(irqIntervals.size());
long lastEndTime = -1;
boolean lastIsNull = true;
for (ITmfStateInterval irqInterval : irqIntervals) {
}
} else if (resourcesEntry.getType().equals(Type.SOFT_IRQ)) {
List<ITmfStateInterval> softIrqIntervals = ssq.queryHistoryRange(quark, realStart, realEnd - 1, resolution, monitor);
- eventList = new ArrayList<ITimeEvent>(softIrqIntervals.size());
+ eventList = new ArrayList<>(softIrqIntervals.size());
long lastEndTime = -1;
boolean lastIsNull = true;
for (ITmfStateInterval softIrqInterval : softIrqIntervals) {
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="src" path="src"/>
<classpathentry kind="src" path="stubs"/>
org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable
org.eclipse.jdt.core.compiler.annotation.nullanalysis=enabled
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.compliance=1.7
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.discouragedReference=error
org.eclipse.jdt.core.compiler.problem.emptyStatement=error
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=warning
+org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=error
org.eclipse.jdt.core.compiler.problem.fallthroughCase=error
org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled
org.eclipse.jdt.core.compiler.problem.fieldHiding=error
org.eclipse.jdt.core.compiler.problem.rawTypeReference=error
org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning
org.eclipse.jdt.core.compiler.problem.redundantNullCheck=error
-org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=warning
+org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=error
org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=error
org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore
org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=error
org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedWarningToken=error
org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=error
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.7
org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
Bundle-Localization: plugin
Bundle-SymbolicName: org.eclipse.linuxtools.lttng2.ui.tests;singleton:=true
Bundle-ActivationPolicy: lazy
-Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
Require-Bundle: org.junit;bundle-version="4.0.0",
org.eclipse.core.commands,
org.eclipse.core.runtime,
public void testGetAndSetChildren() {
TraceControlComponent fixture = new TraceControlComponent("", new TraceControlRoot());
fixture.setToolTip("");
- List<ITraceControlComponent> children = new LinkedList<ITraceControlComponent>();
+ List<ITraceControlComponent> children = new LinkedList<>();
children.add(new TraceControlComponent("child1"));
children.add(new TraceControlComponent("child2"));
EnableEventsDialogStub eventsDialogStub = new EnableEventsDialogStub();
eventsDialogStub.setIsTracePoints(true);
- List<String> events = new ArrayList<String>();
+ List<String> events = new ArrayList<>();
events.add("sched_kthread_stop");
events.add("sched_kthread_stop_ret");
eventsDialogStub.setNames(events);
assertEquals(1, domains.length);
AddContextDialogStub addContextStub = new AddContextDialogStub();
- List<String> contexts = new ArrayList<String>();
+ List<String> contexts = new ArrayList<>();
contexts.add("prio");
contexts.add("perf:branch-misses");
contexts.add("perf:cache-misses");
IPropertyDescriptor[] descriptors = sessionSource.getPropertyDescriptors();
assertNotNull(descriptors);
- Map<String,String> map = new HashMap<String,String>();
+ Map<String,String> map = new HashMap<>();
map.put(TraceSessionPropertySource.TRACE_SESSION_NAME_PROPERTY_ID, "mysession");
map.put(TraceSessionPropertySource.TRACE_SNAPSHOT_NAME_PROPERTY_ID, "snapshot-1");
map.put(TraceSessionPropertySource.TRACE_SNAPSHOT_PATH_PROPERTY_ID, "/home/user/lttng-traces/mysession-20130913-141651");
// ------------------------------------------------------------------------
EnableEventsDialogStub eventsDialogStub = new EnableEventsDialogStub();
eventsDialogStub.setIsTracePoints(true);
- List<String> events = new ArrayList<String>();
+ List<String> events = new ArrayList<>();
events.add("ust_tests_hello:tptest_sighandler");
eventsDialogStub.setNames(events);
eventsDialogStub.setIsKernel(false);
try {
((LTTngControlService)fService).setVersion("2.2.0");
String sessionName = "mysession2";
- List<String> list = new ArrayList<String>();
+ List<String> list = new ArrayList<>();
String kernelChannel0 = "mychannel0";
String kernelChannel1 = "mychannel1";
list.add(kernelChannel0);
try {
((LTTngControlService)fService).setVersion("2.2.0");
String sessionName = "mysession2";
- List<String> list = new ArrayList<String>();
+ List<String> list = new ArrayList<>();
String USTChannel = "ustChannel";
list.add(USTChannel);
fShell.setScenario(SCEN_CHANNEL_HANDLING);
try {
((LTTngControlService)fService).setVersion("2.2.0");
String sessionName = "mysession2";
- List<String> list = new ArrayList<String>();
+ List<String> list = new ArrayList<>();
String USTChannel = "ustChannel";
list.add(USTChannel);
fShell.setScenario(SCEN_CHANNEL_HANDLING);
try {
String sessionName = "mysession2";
- List<String> list = new ArrayList<String>();
+ List<String> list = new ArrayList<>();
String kernelChannel0 = "mychannel0";
String kernelChannel1 = "mychannel1";
list.add(kernelChannel0);
try {
String sessionName = "mysession2";
- List<String> list = new ArrayList<String>();
+ List<String> list = new ArrayList<>();
String kernelChannel0 = "mychannel0";
String kernelChannel1 = "mychannel1";
list.add(kernelChannel0);
try {
// 1) session name, channel = null, 3 event names, kernel
String sessionName = "mysession2";
- List<String> list = new ArrayList<String>();
+ List<String> list = new ArrayList<>();
String eventName0 = "block_rq_remap";
String eventName1 = "block_bio_remap";
String eventName2 = "softirq_entry";
String sessionName = "mysession2";
String channelName = "mychannel";
String eventName = "ust_tests_hello:tptest_sighandler";
- List<String> contexts = new ArrayList<String>();
+ List<String> contexts = new ArrayList<>();
contexts.add("prio");
contexts.add("pid");
assertEquals(12, availContexts.size());
// A very "hard-coded" way to verify but it works ...
- Set<String> expectedContexts = new HashSet<String>();
+ Set<String> expectedContexts = new HashSet<>();
expectedContexts.add("pid");
expectedContexts.add("procname");
expectedContexts.add("prio");
String sessionName = "mysession2";
String channelName = "mychannel";
String eventName = "ust_tests_hello:tptest_sighandler";
- List<String> contexts = new ArrayList<String>();
+ List<String> contexts = new ArrayList<>();
contexts.add("prio");
contexts.add("pid");
fShell.setScenario(SCEN_CONTEXT_ERROR_HANDLING);
@Override
public void setAvalibleContexts(List<String> contexts) {
- fAvailableContexts = new HashSet<String>();
+ fAvailableContexts = new HashSet<>();
fAvailableContexts.addAll(contexts);
}
@Override
public List<String> getContexts() {
- List<String> ret = new ArrayList<String>();
+ List<String> ret = new ArrayList<>();
ret.addAll(fContexts);
return ret;
}
public void setContexts(List<String> contexts) throws IllegalArgumentException{
- fContexts = new ArrayList<String>();
+ fContexts = new ArrayList<>();
fContexts.addAll(contexts);
// If availableContexts are null we cannot verify
if (fAvailableContexts != null) {
private TraceLogLevel fLogLevel;
private LogLevelType fLogLevelType;
private String fFilter;
- List<String> fNames = new ArrayList<String>();
+ private List<String> fNames = new ArrayList<>();
// ------------------------------------------------------------------------
// Accessors
private String fScenariofile;
private String fScenario;
- private final Map<String, Map<String, ICommandResult>> fScenarioMap = new HashMap<String, Map<String, ICommandResult>>();
- private final Map<String, Integer> fSessionNameMap = new HashMap<String, Integer>();
+ private final Map<String, Map<String, ICommandResult>> fScenarioMap = new HashMap<>();
+ private final Map<String, Integer> fSessionNameMap = new HashMap<>();
/**
* Parse a scenario file with the format:
// load from file
// Open the file
- FileInputStream fstream = new FileInputStream(fScenariofile);
+ try (FileInputStream fstream = new FileInputStream(fScenariofile);
+ DataInputStream in = new DataInputStream(fstream);
+ BufferedReader br = new BufferedReader(new InputStreamReader(in));) {
+ String strLine;
- // Get the object of DataInputStream
- DataInputStream in = new DataInputStream(fstream);
- BufferedReader br = new BufferedReader(new InputStreamReader(in));
- String strLine;
+ // Read File Line by Line
- // Read File Line by Line
-
- // Temporary map for generating instance numbers for lttng list <session> commands.
- // The numbers are per scenario.
- Map<String, Integer> tmpSessionNameMap = new HashMap<String, Integer>();
- while ((strLine = br.readLine()) != null) {
-
- // Ignore comments
- if(isComment(strLine)) {
- continue;
- }
-
- if (SCENARIO_KEY.equals(strLine)) {
- // scenario start
+ // Temporary map for generating instance numbers for lttng list
+ // <session> commands.
+ // The numbers are per scenario.
+ Map<String, Integer> tmpSessionNameMap = new HashMap<>();
+ while ((strLine = br.readLine()) != null) {
// Ignore comments
- strLine = br.readLine();
- while (isComment(strLine)) {
- strLine = br.readLine();
+ if (isComment(strLine)) {
+ continue;
}
- String scenario = strLine;
- Map<String, ICommandResult> commandMap = new HashMap<String, ICommandResult>();
- fScenarioMap.put(scenario, commandMap);
- List<String> output = null;
- String input = null;
- boolean inOutput = false;
- int result = 0;
- tmpSessionNameMap.clear();
- while ((strLine = br.readLine()) != null) {
+ if (SCENARIO_KEY.equals(strLine)) {
+ // scenario start
+
// Ignore comments
- if(isComment(strLine)) {
- continue;
+ strLine = br.readLine();
+ while (isComment(strLine)) {
+ strLine = br.readLine();
}
- if (SCENARIO_END_KEY.equals(strLine)) {
- // Scenario is finished
- break;
- }
- if (INPUT_KEY.equals(strLine)) {
- strLine = br.readLine();
+ String scenario = strLine;
+ Map<String, ICommandResult> commandMap = new HashMap<>();
+ fScenarioMap.put(scenario, commandMap);
+ List<String> output = null;
+ String input = null;
+ boolean inOutput = false;
+ int result = 0;
+ tmpSessionNameMap.clear();
+ while ((strLine = br.readLine()) != null) {
// Ignore comments
- while (isComment(strLine)) {
- strLine = br.readLine();
+ if (isComment(strLine)) {
+ continue;
}
- // Read command
- input = strLine;
- // Handle instances of 'lttng list <session"-comamand
- Matcher matcher = LTTNG_LIST_SESSION_PATTERN.matcher(strLine);
- if (matcher.matches() && !input.matches(LTTNG_LIST_PROVIDER_PATTERN)) {
- String sessionName = matcher.group(1).trim();
- Integer i = tmpSessionNameMap.get(sessionName);
- if (i != null) {
- i++;
- } else {
- i = 0;
- }
- tmpSessionNameMap.put(sessionName, i);
- input += String.valueOf(i);
+ if (SCENARIO_END_KEY.equals(strLine)) {
+ // Scenario is finished
+ break;
}
- } else if (INPUT_END_KEY.equals(strLine)) {
- // Initialize output array
- output = new ArrayList<String>();
- } else if (RESULT_KEY.equals(strLine)) {
- strLine = br.readLine();
- // Ignore comments
- while (isComment(strLine)) {
+ if (INPUT_KEY.equals(strLine)) {
strLine = br.readLine();
- }
- // Save result value
- result = Integer.parseInt(strLine);
- } else if (OUTPUT_END_KEY.equals(strLine)) {
- // Save output/result in command map
- if (output != null) {
- commandMap.put(input, new CommandResult(result, output.toArray(new String[output.size()])));
- }
- inOutput = false;
- } else if (OUTPUT_KEY.equals(strLine)) {
- // first line of output
- inOutput = true;
- strLine = br.readLine();
+ // Ignore comments
+ while (isComment(strLine)) {
+ strLine = br.readLine();
+ }
+ // Read command
+ input = strLine;
- // Ignore comments
- while (isComment(strLine)) {
+ // Handle instances of 'lttng list
+ // <session"-comamand
+ Matcher matcher = LTTNG_LIST_SESSION_PATTERN.matcher(strLine);
+ if (matcher.matches() && !input.matches(LTTNG_LIST_PROVIDER_PATTERN)) {
+ String sessionName = matcher.group(1).trim();
+ Integer i = tmpSessionNameMap.get(sessionName);
+ if (i != null) {
+ i++;
+ } else {
+ i = 0;
+ }
+ tmpSessionNameMap.put(sessionName, i);
+ input += String.valueOf(i);
+ }
+ } else if (INPUT_END_KEY.equals(strLine)) {
+ // Initialize output array
+ output = new ArrayList<>();
+ } else if (RESULT_KEY.equals(strLine)) {
strLine = br.readLine();
+ // Ignore comments
+ while (isComment(strLine)) {
+ strLine = br.readLine();
+ }
+ // Save result value
+ result = Integer.parseInt(strLine);
+ } else if (OUTPUT_END_KEY.equals(strLine)) {
+ // Save output/result in command map
+ if (output != null) {
+ commandMap.put(input, new CommandResult(result, output.toArray(new String[output.size()])));
+ }
+ inOutput = false;
+ } else if (OUTPUT_KEY.equals(strLine)) {
+ // first line of output
+ inOutput = true;
+ strLine = br.readLine();
+
+ // Ignore comments
+ while (isComment(strLine)) {
+ strLine = br.readLine();
+ }
+ if (output != null) {
+ output.add(strLine);
+ }
+ } else if (inOutput) {
+ // subsequent lines of output
+ if (output != null) {
+ output.add(strLine);
+ }
}
- if (output != null) {
- output.add(strLine);
- }
- } else if (inOutput) {
- // subsequent lines of output
- if (output != null) {
- output.add(strLine);
- }
- }
-// else {
-// if (RESULT_END_KEY.equals(strLine)) {
+ // else {
+ // if (RESULT_END_KEY.equals(strLine)) {
// nothing to do
-// }
+ // }
+ }
}
}
}
- //Close the input stream
- in.close();
}
// Set the scenario to consider in executeCommand()
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="src" path="src"/>
<classpathentry kind="output" path="bin"/>
org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable
org.eclipse.jdt.core.compiler.annotation.nullanalysis=enabled
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.compliance=1.7
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.discouragedReference=error
org.eclipse.jdt.core.compiler.problem.emptyStatement=error
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=warning
+org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=error
org.eclipse.jdt.core.compiler.problem.fallthroughCase=error
org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled
org.eclipse.jdt.core.compiler.problem.fieldHiding=error
org.eclipse.jdt.core.compiler.problem.rawTypeReference=error
org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning
org.eclipse.jdt.core.compiler.problem.redundantNullCheck=error
-org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=warning
+org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=error
org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=error
org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore
org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=error
org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedWarningToken=error
org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=error
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.7
org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
Bundle-SymbolicName: org.eclipse.linuxtools.lttng2.ui;singleton:=true
Bundle-Activator: org.eclipse.linuxtools.internal.lttng2.ui.Activator
Bundle-ActivationPolicy: lazy
-Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
Require-Bundle: org.eclipse.ui,
org.eclipse.ui.ide,
org.eclipse.core.expressions,
/**
* The contexts to add.
*/
- private final List<String> fSelectedContexts = new ArrayList<String>();
+ private final List<String> fSelectedContexts = new ArrayList<>();
// ------------------------------------------------------------------------
// Constructors
@Override
public List<String> getContexts() {
- List<String> ret = new ArrayList<String>();
+ List<String> ret = new ArrayList<>();
ret.addAll(fSelectedContexts);
return ret;
}
* The contexts to set
*/
public void setAvalibleContexts(List<String> contexts) {
- fAvailableContexts = new ArrayList<Context>();
+ fAvailableContexts = new ArrayList<>();
if (contexts != null) {
for (Iterator<String> iterator = contexts.iterator(); iterator.hasNext();) {
String name = iterator.next();
@Override
public List<String> getEventNames() {
- return new ArrayList<String>(fSelectedEvents);
+ return new ArrayList<>(fSelectedEvents);
}
@Override
// initialize tracepoint fields
fIsAllTracepoints = false;
- fSelectedEvents = new ArrayList<String>();
+ fSelectedEvents = new ArrayList<>();
if (fIsTracepoints) {
List<ITraceControlComponent> comps = fProviderGroup.getChildren(KernelProviderComponent.class);
@Override
public List<String> getEventNames() {
- return new ArrayList<String>(fSelectedEvents);
+ return new ArrayList<>(fSelectedEvents);
}
@Override
// initialize tracepoint fields
fIsAllTracepoints = false;
- fSelectedEvents = new ArrayList<String>();
+ fSelectedEvents = new ArrayList<>();
if (fIsTracepoints) {
fIsAllTracepoints = fTracepointsViewer.getChecked(fProviderGroup);
- Set<String> set = new HashSet<String>();
+ Set<String> set = new HashSet<>();
Object[] checkedElements = fTracepointsViewer.getCheckedElements();
for (int i = 0; i < checkedElements.length; i++) {
ITraceControlComponent component = (ITraceControlComponent)checkedElements[i];
/**
* List of traces to import
*/
- private final List<ImportFileInfo> fTraces = new ArrayList<ImportFileInfo>();
+ private final List<ImportFileInfo> fTraces = new ArrayList<>();
/**
* Selection index in project combo box.
*/
@Override
public List<ImportFileInfo> getTracePathes() {
- List<ImportFileInfo> retList = new ArrayList<ImportFileInfo>();
+ List<ImportFileInfo> retList = new ArrayList<>();
retList.addAll(fTraces);
return retList;
}
projectGroup.setLayout(layout);
projectGroup.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
- fProjects = new ArrayList<IProject>();
- List<String> projectNames = new ArrayList<String>();
+ fProjects = new ArrayList<>();
+ List<String> projectNames = new ArrayList<>();
for (IProject project : TraceUtils.getOpenedTmfProjects()) {
fProjects.add(project);
Exception error = null;
try {
- List<String> eventNames = new ArrayList<String>();
+ List<String> eventNames = new ArrayList<>();
List<BaseEventComponent> events = param.getEvents();
// Create list of event names
for (Iterator<BaseEventComponent> iterator = events.iterator(); iterator.hasNext();) {
@Override
public boolean isEnabled() {
- ArrayList<BaseEventComponent> events = new ArrayList<BaseEventComponent>();
+ ArrayList<BaseEventComponent> events = new ArrayList<>();
TraceSessionComponent[] sessions = null;
Boolean isKernel = null;
*/
public Parameter(TraceSessionComponent[] sessions, List<BaseEventComponent> events, boolean isKernel) {
fSessions = Arrays.copyOf(sessions, sessions.length);
- fEvents = new ArrayList<BaseEventComponent>();
+ fEvents = new ArrayList<>();
fEvents.addAll(events);
fIsKernel = isKernel;
}
protected IStatus run(IProgressMonitor monitor) {
Exception error = null;
- List<String> channelNames = new ArrayList<String>();
+ List<String> channelNames = new ArrayList<>();
channelNames.add(dialog.getChannelInfo().getName());
try {
if (kernelDomain != null) {
session = (TraceSessionComponent)kernelDomain.getParent();
- List<String> channelNames = new ArrayList<String>();
+ List<String> channelNames = new ArrayList<>();
for (Iterator<TraceChannelComponent> iterator = kernelChannels.iterator(); iterator.hasNext();) {
// Enable all selected channels which are disabled
TraceChannelComponent channel = iterator.next();
session = (TraceSessionComponent)ustDomain.getParent();
}
- List<String> channelNames = new ArrayList<String>();
+ List<String> channelNames = new ArrayList<>();
for (Iterator<TraceChannelComponent> iterator = ustChannels.iterator(); iterator.hasNext();) {
// Enable all selected channels which are disabled
TraceChannelComponent channel = iterator.next();
TraceDomainComponent kernelDomain = null;
TraceDomainComponent ustDomain = null;
- List<TraceChannelComponent> kernelChannels = new ArrayList<TraceChannelComponent>();
- List<TraceChannelComponent> ustChannels = new ArrayList<TraceChannelComponent>();
+ List<TraceChannelComponent> kernelChannels = new ArrayList<>();
+ List<TraceChannelComponent> ustChannels = new ArrayList<>();
// Check if one or more session are selected
ISelection selection = page.getSelection(ControlView.ID);
public Parameter(TraceDomainComponent kernelDomain, TraceDomainComponent ustDomain, List<TraceChannelComponent> kernelChannels, List<TraceChannelComponent> ustChannels) {
fKernelDomain = kernelDomain;
fUstDomain = ustDomain;
- fKernelChannels = new ArrayList<TraceChannelComponent>();
+ fKernelChannels = new ArrayList<>();
fKernelChannels.addAll(kernelChannels);
- fUstChannels = new ArrayList<TraceChannelComponent>();
+ fUstChannels = new ArrayList<>();
fUstChannels.addAll(ustChannels);
}
boolean isAll = false;
if (param.getChannel() != null) {
session = param.getChannel().getSession();
- List<String> eventNames = new ArrayList<String>();
+ List<String> eventNames = new ArrayList<>();
List<TraceEventComponent> events = param.getEvents();
for (Iterator<TraceEventComponent> iterator = events.iterator(); iterator.hasNext();) {
ISelection selection = page.getSelection(ControlView.ID);
TraceChannelComponent channel = null;
- List<TraceEventComponent> events = new ArrayList<TraceEventComponent>();
+ List<TraceEventComponent> events = new ArrayList<>();
if (selection instanceof StructuredSelection) {
StructuredSelection structered = ((StructuredSelection) selection);
/**
* The list of kernel channel components the command is to be executed on.
*/
- private final List<TraceEventComponent> fEvents = new ArrayList<TraceEventComponent>();
+ private final List<TraceEventComponent> fEvents = new ArrayList<>();
/**
* Constructor
/**
* The list of session components the command is to be executed on.
*/
- protected List<TraceSessionComponent> fSessions = new ArrayList<TraceSessionComponent>();
+ protected List<TraceSessionComponent> fSessions = new ArrayList<>();
// ------------------------------------------------------------------------
// Accessors
fLock.lock();
try {
- final List<TraceSessionComponent> sessions = new ArrayList<TraceSessionComponent>();
+ final List<TraceSessionComponent> sessions = new ArrayList<>();
sessions.addAll(fSessions);
Job job = new Job(Messages.TraceControl_ChangeSessionStateJob) {
return false;
}
- List<TraceSessionComponent> sessions = new ArrayList<TraceSessionComponent>(0);
+ List<TraceSessionComponent> sessions = new ArrayList<>(0);
// Check if one or more session are selected
ISelection selection = page.getSelection(ControlView.ID);
/**
* The list of session components the command is to be executed on.
*/
- private final List<TraceSessionComponent> fSessions = new ArrayList<TraceSessionComponent>();
+ private final List<TraceSessionComponent> fSessions = new ArrayList<>();
// ------------------------------------------------------------------------
// Operations
private static IHost[] getSuitableHosts() {
// need shells and files
- ArrayList<IHost> result = new ArrayList<IHost>();
- ArrayList<IHost> shellConnections = new ArrayList<IHost>(
+ ArrayList<IHost> result = new ArrayList<>();
+ ArrayList<IHost> shellConnections = new ArrayList<>(
Arrays.asList(RSECorePlugin.getTheSystemRegistry()
.getHostsBySubSystemConfigurationCategory("shells"))); //$NON-NLS-1$
/**
* The list of session components the command is to be executed on.
*/
- protected List<TraceSessionComponent> fSessions = new ArrayList<TraceSessionComponent>();
+ protected List<TraceSessionComponent> fSessions = new ArrayList<>();
// ------------------------------------------------------------------------
// Operations
fLock.lock();
try {
// Make a copy for thread safety
- final List<TraceSessionComponent> sessions = new ArrayList<TraceSessionComponent>();
+ final List<TraceSessionComponent> sessions = new ArrayList<>();
sessions.addAll(fSessions);
Job job = new Job(Messages.TraceControl_RecordSnapshotJob) {
return false;
}
- List<TraceSessionComponent> sessions = new ArrayList<TraceSessionComponent>(0);
+ List<TraceSessionComponent> sessions = new ArrayList<>(0);
// Check if one session is selected
ISelection selection = page.getSelection(ControlView.ID);
public void setChannelInfo(IChannelInfo channelInfo) {
fChannelInfo = channelInfo;
IEventInfo[] events = fChannelInfo.getEvents();
- List<ITraceControlComponent> eventComponents = new ArrayList<ITraceControlComponent>();
+ List<ITraceControlComponent> eventComponents = new ArrayList<>();
for (int i = 0; i < events.length; i++) {
TraceEventComponent event = null;
if (events[i].getClass() == ProbeEventInfo.class) {
/**
* The list if children components.
*/
- private final List<ITraceControlComponent> fChildren = new ArrayList<ITraceControlComponent>();
+ private final List<ITraceControlComponent> fChildren = new ArrayList<>();
/**
* The list of listeners to be notified about changes.
*/
@Override
public List<ITraceControlComponent> getChildren(Class<? extends ITraceControlComponent> clazz) {
- List<ITraceControlComponent> list = new ArrayList<ITraceControlComponent>();
+ List<ITraceControlComponent> list = new ArrayList<>();
for (Iterator<ITraceControlComponent> iterator = fChildren.iterator(); iterator.hasNext();) {
ITraceControlComponent child = iterator.next();
@Override
public IPropertyDescriptor[] getPropertyDescriptors() {
- List<IPropertyDescriptor> list = new ArrayList<IPropertyDescriptor> ();
+ List<IPropertyDescriptor> list = new ArrayList<> ();
list.add(new ReadOnlyTextPropertyDescriptor(BASE_EVENT_NAME_PROPERTY_ID, BASE_EVENT_NAME_PROPERTY_NAME));
list.add(new ReadOnlyTextPropertyDescriptor(BASE_EVENT_TYPE_PROPERTY_ID, BASE_EVENT_TYPE_PROPERTY_NAME));
if (fBaseEvent.getLogLevel() != TraceLogLevel.LEVEL_UNKNOWN) {
@Override
public IPropertyDescriptor[] getPropertyDescriptors() {
- List<IPropertyDescriptor> list = new ArrayList<IPropertyDescriptor> ();
+ List<IPropertyDescriptor> list = new ArrayList<> ();
list.add(new ReadOnlyTextPropertyDescriptor(TRACE_EVENT_NAME_PROPERTY_ID, TRACE_EVENT_NAME_PROPERTY_NAME));
list.add(new ReadOnlyTextPropertyDescriptor(TRACE_EVENT_TYPE_PROPERTY_ID, TRACE_EVENT_TYPE_PROPERTY_NAME));
list.add( new ReadOnlyTextPropertyDescriptor(TRACE_EVENT_STATE_PROPERTY_ID, TRACE_EVENT_STATE_PROPERTY_NAME));
IPropertyDescriptor[] superProperties = super.getPropertyDescriptors();
List<IPropertyDescriptor> superList = Arrays.asList(superProperties);
- ArrayList<IPropertyDescriptor> list = new ArrayList<IPropertyDescriptor>();
+ ArrayList<IPropertyDescriptor> list = new ArrayList<>();
list.addAll(superList);
if (fEvent instanceof TraceProbeEventComponent) {
@Override
public IPropertyDescriptor[] getPropertyDescriptors() {
- List<IPropertyDescriptor> list = new ArrayList<IPropertyDescriptor> ();
+ List<IPropertyDescriptor> list = new ArrayList<>();
list.add(new ReadOnlyTextPropertyDescriptor(TRACE_SESSION_NAME_PROPERTY_ID, TRACE_SESSION_NAME_PROPERTY_NAME));
list.add(new ReadOnlyTextPropertyDescriptor(TRACE_SESSION_STATE_PROPERTY_ID, TRACE_SESSION_STATE_PROPERTY_NAME));
if (fSession.isSnapshotSession()) {
@Override
public ICommandResult executeCommand(final String command, final IProgressMonitor monitor, final boolean checkReturnValue) throws ExecutionException {
if (fIsConnected) {
- FutureTask<CommandResult> future = new FutureTask<CommandResult>(new Callable<CommandResult>() {
+ FutureTask<CommandResult> future = new FutureTask<>(new Callable<CommandResult>() {
@Override
public CommandResult call() throws IOException, CancellationException {
- final ArrayList<String> result = new ArrayList<String>();
+ final ArrayList<String> result = new ArrayList<>();
synchronized (fHostShell) {
// Initialize return value which will be updated in isAliasEchoResult()
//
// Use lttng list <session_name> for more details
- ArrayList<String> retArray = new ArrayList<String>();
+ ArrayList<String> retArray = new ArrayList<>();
int index = 0;
while (index < result.getOutput().length) {
String line = result.getOutput()[index];
domainInfo.setIsKernel(true);
// in domain kernel
- ArrayList<IChannelInfo> channels = new ArrayList<IChannelInfo>();
+ ArrayList<IChannelInfo> channels = new ArrayList<>();
index = parseDomain(result.getOutput(), index, channels, domainInfo);
if (channels.size() > 0) {
domainInfo.setIsKernel(false);
// in domain UST
- ArrayList<IChannelInfo> channels = new ArrayList<IChannelInfo>();
+ ArrayList<IChannelInfo> channels = new ArrayList<>();
index = parseDomain(result.getOutput(), index, channels, domainInfo);
if (channels.size() > 0) {
StringBuffer command = createCommand(LTTngControlServiceConstants.COMMAND_LIST_KERNEL);
ICommandResult result = executeCommand(command.toString(), monitor, false);
- List<IBaseEventInfo> events = new ArrayList<IBaseEventInfo>();
+ List<IBaseEventInfo> events = new ArrayList<>();
if (result.getOutput() != null) {
// Ignore the following 2 cases:
}
ICommandResult result = executeCommand(command.toString(), monitor, false);
- List<IUstProviderInfo> allProviders = new ArrayList<IUstProviderInfo>();
+ List<IUstProviderInfo> allProviders = new ArrayList<>();
// Workaround for versions 2.0.x which causes a segmentation fault for this command
// if LTTng Tools is compiled without UST support.
if (matcher.matches()) {
provider = new UstProviderInfo(matcher.group(2).trim());
provider.setPid(Integer.valueOf(matcher.group(1).trim()));
- List<IBaseEventInfo> events = new ArrayList<IBaseEventInfo>();
+ List<IBaseEventInfo> events = new ArrayList<>();
index = getProviderEventInfo(result.getOutput(), ++index, events);
provider.setEvents(events);
allProviders.add(provider);
String[] output = result.getOutput();
- List<String> contexts = new ArrayList<String>(0);
+ List<String> contexts = new ArrayList<>(0);
int index = 0;
boolean inList = false;
}
} else if (LTTngControlServiceConstants.EVENT_SECTION_PATTERN.matcher(subLine).matches()) {
- List<IEventInfo> events = new ArrayList<IEventInfo>();
+ List<IEventInfo> events = new ArrayList<>();
index = parseEvents(output, index, events);
if (channelInfo != null) {
channelInfo.setEvents(events);
index++;
} else if (LTTngControlServiceConstants.EVENT_FIELD_PATTERN.matcher(line).matches()) {
if (eventInfo != null) {
- List<IFieldInfo> fields = new ArrayList<IFieldInfo>();
+ List<IFieldInfo> fields = new ArrayList<>();
index = getFieldInfo(output, index, fields);
eventInfo.setFields(fields);
} else {
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="src" path="src"/>
<classpathentry kind="output" path="bin"/>
org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable
org.eclipse.jdt.core.compiler.annotation.nullanalysis=enabled
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.compliance=1.7
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.discouragedReference=warning
org.eclipse.jdt.core.compiler.problem.emptyStatement=warning
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=warning
+org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=error
org.eclipse.jdt.core.compiler.problem.fallthroughCase=warning
org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled
org.eclipse.jdt.core.compiler.problem.fieldHiding=warning
org.eclipse.jdt.core.compiler.problem.rawTypeReference=warning
org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning
org.eclipse.jdt.core.compiler.problem.redundantNullCheck=warning
-org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=warning
+org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=error
org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=warning
org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore
org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=warning
org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.7
org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
Bundle-Localization: plugin
Bundle-SymbolicName: org.eclipse.linuxtools.lttng2.ust.core.tests;singleton:=true
Bundle-ActivationPolicy: lazy
-Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
Require-Bundle: org.junit;bundle-version="4.0.0",
org.eclipse.core.resources,
org.eclipse.core.runtime,
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="src" path="src"/>
<classpathentry kind="output" path="bin"/>
org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable
org.eclipse.jdt.core.compiler.annotation.nullanalysis=enabled
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.compliance=1.7
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.discouragedReference=warning
org.eclipse.jdt.core.compiler.problem.emptyStatement=warning
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=warning
+org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=error
org.eclipse.jdt.core.compiler.problem.fallthroughCase=warning
org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled
org.eclipse.jdt.core.compiler.problem.fieldHiding=warning
org.eclipse.jdt.core.compiler.problem.rawTypeReference=warning
org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning
org.eclipse.jdt.core.compiler.problem.redundantNullCheck=warning
-org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=warning
+org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=error
org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=warning
org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore
org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=warning
org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.7
org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
Bundle-SymbolicName: org.eclipse.linuxtools.lttng2.ust.core;singleton:=true
Bundle-Activator: org.eclipse.linuxtools.internal.lttng2.ust.core.Activator
Bundle-ActivationPolicy: lazy
-Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
Export-Package: org.eclipse.linuxtools.internal.lttng2.ust.core;x-internal:=true,
org.eclipse.linuxtools.internal.lttng2.ust.core.trace.callstack;x-internal:=true,
org.eclipse.linuxtools.lttng2.ust.core.trace
private static final String FIELD_ADDR = "addr"; //$NON-NLS-1$
/** Event names indicating function entry */
- private static final Set<String> FUNC_ENTRY_EVENTS = new HashSet<String>();
+ private static final Set<String> FUNC_ENTRY_EVENTS = new HashSet<>();
/** Event names indicating function exit */
- private static final Set<String> FUNC_EXIT_EVENTS = new HashSet<String>();
+ private static final Set<String> FUNC_EXIT_EVENTS = new HashSet<>();
static {
/* This seems overkill, but it will be checked every event. Gotta go FAST! */
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="src" path="src"/>
<classpathentry kind="output" path="bin"/>
org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable
org.eclipse.jdt.core.compiler.annotation.nullanalysis=enabled
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.compliance=1.7
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.discouragedReference=warning
org.eclipse.jdt.core.compiler.problem.emptyStatement=warning
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=warning
+org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=error
org.eclipse.jdt.core.compiler.problem.fallthroughCase=warning
org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled
org.eclipse.jdt.core.compiler.problem.fieldHiding=warning
org.eclipse.jdt.core.compiler.problem.rawTypeReference=warning
org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning
org.eclipse.jdt.core.compiler.problem.redundantNullCheck=warning
-org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=warning
+org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=error
org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=warning
org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore
org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=warning
org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.7
org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
Bundle-Localization: plugin
Bundle-SymbolicName: org.eclipse.linuxtools.lttng2.ust.ui.tests;singleton:=true
Bundle-ActivationPolicy: lazy
-Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
Require-Bundle: org.junit;bundle-version="4.0.0",
org.eclipse.ui,
org.eclipse.core.resources,
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="src" path="src"/>
<classpathentry kind="output" path="bin"/>
org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable
org.eclipse.jdt.core.compiler.annotation.nullanalysis=enabled
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.compliance=1.7
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.discouragedReference=warning
org.eclipse.jdt.core.compiler.problem.emptyStatement=warning
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=warning
+org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=error
org.eclipse.jdt.core.compiler.problem.fallthroughCase=warning
org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled
org.eclipse.jdt.core.compiler.problem.fieldHiding=warning
org.eclipse.jdt.core.compiler.problem.rawTypeReference=warning
org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning
org.eclipse.jdt.core.compiler.problem.redundantNullCheck=warning
-org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=warning
+org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=error
org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=warning
org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore
org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=warning
org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.7
org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
Bundle-SymbolicName: org.eclipse.linuxtools.lttng2.ust.ui;singleton:=true
Bundle-Activator: org.eclipse.linuxtools.internal.lttng2.ust.ui.Activator
Bundle-ActivationPolicy: lazy
-Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
Require-Bundle: org.eclipse.core.resources,
org.eclipse.core.runtime,
org.eclipse.ui,
projects / deliverable / tracecompass.git / commitdiff
