requirements: make TmfAnalysisRequirement abstract

Change-Id: I87d7e2d1da00fb1ac023fdeb4b38734e10aa6807
Signed-off-by: Geneviève Bastien <gbastien+lttng@versatic.net>

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/cpuusage/KernelCpuUsageAnalysis.java b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/cpuusage/KernelCpuUsageAnalysis.java
index 195e63114c2a5a36f18d79020e7244edbd3bb288..98d9446d84fd4bdcef1fc302e12eadad49936e60 100644 (file)
--- a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/cpuusage/KernelCpuUsageAnalysis.java
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/cpuusage/KernelCpuUsageAnalysis.java
@@ -38,8 +38,8 @@ import org.eclipse.tracecompass.statesystem.core.exceptions.StateValueTypeExcept
 import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException;
 import org.eclipse.tracecompass.statesystem.core.interval.ITmfStateInterval;
 import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.PriorityLevel;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement.PriorityLevel;
 import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;
 import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
@@ -69,7 +69,7 @@ public class KernelCpuUsageAnalysis extends TmfStateSystemAnalysisModule {
 
     /** The requirements as an immutable set */
     private static final KernelEventLayoutRequirement LAYOUT_REQUIREMENT;
-    private static final SetMultimap<IKernelAnalysisEventLayout, TmfAnalysisRequirement> LAYOUT_REQ_MAP = NonNullUtils.checkNotNull(HashMultimap.create());
+    private static final SetMultimap<IKernelAnalysisEventLayout, TmfAbstractAnalysisRequirement> LAYOUT_REQ_MAP = NonNullUtils.checkNotNull(HashMultimap.create());
 
     static {
         LAYOUT_REQUIREMENT = new KernelEventLayoutRequirement(ImmutableSet.of((l) -> l.eventSchedSwitch()), PriorityLevel.MANDATORY);
@@ -333,10 +333,10 @@ public class KernelCpuUsageAnalysis extends TmfStateSystemAnalysisModule {
     }
 
     @Override
-    public Iterable<TmfAnalysisRequirement> getAnalysisRequirements() {
+    public Iterable<TmfAbstractAnalysisRequirement> getAnalysisRequirements() {
         ITmfTrace trace = getTrace();
         IKernelAnalysisEventLayout layout = getLayout(trace);
-        Set<TmfAnalysisRequirement> reqs = LAYOUT_REQ_MAP.get(layout);
+        Set<TmfAbstractAnalysisRequirement> reqs = LAYOUT_REQ_MAP.get(layout);
         if (reqs.isEmpty()) {
             reqs= ImmutableSet.of(LAYOUT_REQUIREMENT.instanciateRequirements(layout));
             LAYOUT_REQ_MAP.putAll(layout, reqs);

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/kernel/KernelAnalysisModule.java b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/kernel/KernelAnalysisModule.java
index b216f7dea4d33c7c991fde3a47da70a3f45cad18..f7b68c3c96d3dc423d10f1ee51ba7440ede7ade7 100644 (file)
--- a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/kernel/KernelAnalysisModule.java
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/kernel/KernelAnalysisModule.java
@@ -24,7 +24,7 @@ import org.eclipse.tracecompass.analysis.os.linux.core.trace.IKernelAnalysisEven
 import org.eclipse.tracecompass.analysis.os.linux.core.trace.IKernelTrace;
 import org.eclipse.tracecompass.common.core.NonNullUtils;
 import org.eclipse.tracecompass.internal.analysis.os.linux.core.kernel.KernelStateProvider;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
 import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;
 import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
@@ -68,7 +68,7 @@ public class KernelAnalysisModule extends TmfStateSystemAnalysisModule {
             // );
 
     /** The requirements as an immutable set */
-    private static final Set<TmfAnalysisRequirement> REQUIREMENTS;
+    private static final Set<TmfAbstractAnalysisRequirement> REQUIREMENTS;
 
     static {
 //        /* initialize the requirement: domain and events */
@@ -103,7 +103,7 @@ public class KernelAnalysisModule extends TmfStateSystemAnalysisModule {
     }
 
     @Override
-    public Iterable<TmfAnalysisRequirement> getAnalysisRequirements() {
+    public Iterable<TmfAbstractAnalysisRequirement> getAnalysisRequirements() {
         return REQUIREMENTS;
     }
 }

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/tid/TidAnalysisModule.java b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/tid/TidAnalysisModule.java
index 53182a428140b089b80c0f1d50ea6c6a1d2f151b..cf261f4176c8c2cf2e888aeddee6cf2deaf53736 100644 (file)
--- a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/tid/TidAnalysisModule.java
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/tid/TidAnalysisModule.java
@@ -28,7 +28,7 @@ import org.eclipse.tracecompass.statesystem.core.exceptions.StateSystemDisposedE
 import org.eclipse.tracecompass.statesystem.core.interval.ITmfStateInterval;
 import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
 import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue.Type;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
 import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;
 import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
@@ -50,10 +50,10 @@ public class TidAnalysisModule extends TmfStateSystemAnalysisModule {
     public static final @NonNull String ID = "org.eclipse.tracecompass.analysis.os.linux.kernel.tid"; //$NON-NLS-1$
 
     /** The requirements as an immutable set */
-    private static final @NonNull Set<@NonNull TmfAnalysisRequirement> REQUIREMENTS = Collections.EMPTY_SET;
+    private static final @NonNull Set<@NonNull TmfAbstractAnalysisRequirement> REQUIREMENTS = Collections.EMPTY_SET;
 
     @Override
-    public @NonNull Iterable<@NonNull TmfAnalysisRequirement> getAnalysisRequirements() {
+    public @NonNull Iterable<@NonNull TmfAbstractAnalysisRequirement> getAnalysisRequirements() {
         return REQUIREMENTS;
     }
 

diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/trace/KernelEventLayoutRequirement.java b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/trace/KernelEventLayoutRequirement.java
index f17c32be0f20d42df81b2bb2a25d1c5ec55f2855..c248bfa85cb31ec3f0d24bb0fb965ddb6b55711b 100644 (file)
--- a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/trace/KernelEventLayoutRequirement.java
+++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/analysis/os/linux/core/trace/KernelEventLayoutRequirement.java
@@ -13,8 +13,8 @@ import java.util.Set;
 
 import org.eclipse.jdt.annotation.Nullable;
 import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisEventRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.PriorityLevel;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement.PriorityLevel;
 
 import com.google.common.collect.ImmutableList.Builder;
 
@@ -69,7 +69,7 @@ public class KernelEventLayoutRequirement {
      *            The event layout from which to build the requirements.
      * @return The real requirement
      */
-    public TmfAnalysisRequirement instanciateRequirements(IKernelAnalysisEventLayout layout) {
+    public TmfAbstractAnalysisRequirement instanciateRequirements(IKernelAnalysisEventLayout layout) {
         Builder<String> events = new Builder<>();
         for (ILayoutToEventName eventNameLayout : fEventNames) {
             String eventName = eventNameLayout.getEventName(layout);

diff --git a/lttng/org.eclipse.tracecompass.lttng2.ust.core.tests/src/org/eclipse/tracecompass/lttng2/ust/core/tests/analysis/debuginfo/UstDebugInfoAnalysisModuleTest.java b/lttng/org.eclipse.tracecompass.lttng2.ust.core.tests/src/org/eclipse/tracecompass/lttng2/ust/core/tests/analysis/debuginfo/UstDebugInfoAnalysisModuleTest.java
index e1daa201822809255be7d0374d67d058d8b3fada..d818afbba786bd688b821cafc8476ed0b5c71232 100644 (file)
--- a/lttng/org.eclipse.tracecompass.lttng2.ust.core.tests/src/org/eclipse/tracecompass/lttng2/ust/core/tests/analysis/debuginfo/UstDebugInfoAnalysisModuleTest.java
+++ b/lttng/org.eclipse.tracecompass.lttng2.ust.core.tests/src/org/eclipse/tracecompass/lttng2/ust/core/tests/analysis/debuginfo/UstDebugInfoAnalysisModuleTest.java
@@ -28,7 +28,7 @@ import org.eclipse.tracecompass.lttng2.ust.core.trace.LttngUstEvent;
 import org.eclipse.tracecompass.lttng2.ust.core.trace.LttngUstTrace;
 import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
 import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
 import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
 import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
@@ -89,7 +89,7 @@ public class UstDebugInfoAnalysisModuleTest {
      */
     @Test
     public void testGetAnalysisRequirements() {
-        Iterable<TmfAnalysisRequirement> requirements = fModule.getAnalysisRequirements();
+        Iterable<TmfAbstractAnalysisRequirement> requirements = fModule.getAnalysisRequirements();
         assertNotNull(requirements);
         assertTrue(Iterables.isEmpty(requirements));
     }

diff --git a/lttng/org.eclipse.tracecompass.lttng2.ust.core.tests/src/org/eclipse/tracecompass/lttng2/ust/core/tests/analysis/memory/UstMemoryAnalysisModuleTest.java b/lttng/org.eclipse.tracecompass.lttng2.ust.core.tests/src/org/eclipse/tracecompass/lttng2/ust/core/tests/analysis/memory/UstMemoryAnalysisModuleTest.java
index 95ccebe10755e982efeb18c1c1ed5371040b74f9..04f87ca674e6215c284980ac135f740babd27290 100644 (file)
--- a/lttng/org.eclipse.tracecompass.lttng2.ust.core.tests/src/org/eclipse/tracecompass/lttng2/ust/core/tests/analysis/memory/UstMemoryAnalysisModuleTest.java
+++ b/lttng/org.eclipse.tracecompass.lttng2.ust.core.tests/src/org/eclipse/tracecompass/lttng2/ust/core/tests/analysis/memory/UstMemoryAnalysisModuleTest.java
@@ -16,7 +16,7 @@ import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
 
 import org.eclipse.tracecompass.lttng2.ust.core.analysis.memory.UstMemoryAnalysisModule;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
 import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Test;
@@ -45,7 +45,7 @@ public class UstMemoryAnalysisModuleTest {
     @Ignore("Need to assign a trace to the module to check the requirements now")
     @Test
     public void testGetAnalysisRequirements() {
-        Iterable<TmfAnalysisRequirement> requirements = fUstAnalysisModule.getAnalysisRequirements();
+        Iterable<TmfAbstractAnalysisRequirement> requirements = fUstAnalysisModule.getAnalysisRequirements();
 
         assertNotNull(requirements);
         assertTrue(requirements.iterator().hasNext());

diff --git a/lttng/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/lttng2/ust/core/analysis/debuginfo/UstDebugInfoAnalysisModule.java b/lttng/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/lttng2/ust/core/analysis/debuginfo/UstDebugInfoAnalysisModule.java
index 61f8703900a58f8a5fc0cd81c769f132ed6dc618..4953d989f942c17f34e435ab732ad0e0aeadd4ce 100644 (file)
--- a/lttng/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/lttng2/ust/core/analysis/debuginfo/UstDebugInfoAnalysisModule.java
+++ b/lttng/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/lttng2/ust/core/analysis/debuginfo/UstDebugInfoAnalysisModule.java
@@ -31,7 +31,7 @@ import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundExc
 import org.eclipse.tracecompass.statesystem.core.exceptions.StateSystemDisposedException;
 import org.eclipse.tracecompass.statesystem.core.interval.ITmfStateInterval;
 import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
 import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
 import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;
 import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
@@ -73,7 +73,7 @@ public class UstDebugInfoAnalysisModule extends TmfStateSystemAnalysisModule {
     }
 
     @Override
-    public Iterable<TmfAnalysisRequirement> getAnalysisRequirements() {
+    public Iterable<TmfAbstractAnalysisRequirement> getAnalysisRequirements() {
         // TODO specify actual requirements once the requirement-checking is
         // implemented. This analysis needs "ip" and "vpid" contexts.
         return Collections.EMPTY_SET;

diff --git a/lttng/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/lttng2/ust/core/analysis/memory/UstMemoryAnalysisModule.java b/lttng/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/lttng2/ust/core/analysis/memory/UstMemoryAnalysisModule.java
index bb4b26b5466e6e29c39d8a8b5163e72864911f53..8b5a22ef44b87bd555aba37516bfbe0aecdcc5cc 100644 (file)
--- a/lttng/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/lttng2/ust/core/analysis/memory/UstMemoryAnalysisModule.java
+++ b/lttng/org.eclipse.tracecompass.lttng2.ust.core/src/org/eclipse/tracecompass/lttng2/ust/core/analysis/memory/UstMemoryAnalysisModule.java
@@ -24,8 +24,8 @@ import org.eclipse.tracecompass.internal.lttng2.ust.core.analysis.memory.UstMemo
 import org.eclipse.tracecompass.lttng2.ust.core.trace.LttngUstTrace;
 import org.eclipse.tracecompass.lttng2.ust.core.trace.layout.ILttngUstEventLayout;
 import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisEventRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.PriorityLevel;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement.PriorityLevel;
 import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
 import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;
 import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
@@ -47,7 +47,7 @@ public class UstMemoryAnalysisModule extends TmfStateSystemAnalysisModule {
     public static final @NonNull String ID = "org.eclipse.linuxtools.lttng2.ust.analysis.memory"; //$NON-NLS-1$
 
     /** The analysis's requirements. Only set after the trace is set. */
-    private @Nullable Set<TmfAnalysisRequirement> fAnalysisRequirements;
+    private @Nullable Set<TmfAbstractAnalysisRequirement> fAnalysisRequirements;
 
     @Override
     protected ITmfStateProvider createStateProvider() {
@@ -71,8 +71,8 @@ public class UstMemoryAnalysisModule extends TmfStateSystemAnalysisModule {
     }
 
     @Override
-    public Iterable<TmfAnalysisRequirement> getAnalysisRequirements() {
-        Set<TmfAnalysisRequirement> requirements = fAnalysisRequirements;
+    public Iterable<TmfAbstractAnalysisRequirement> getAnalysisRequirements() {
+        Set<TmfAbstractAnalysisRequirement> requirements = fAnalysisRequirements;
         if (requirements == null) {
             LttngUstTrace trace = getTrace();
             ILttngUstEventLayout layout;
@@ -92,7 +92,7 @@ public class UstMemoryAnalysisModule extends TmfStateSystemAnalysisModule {
                   );
 
             /* Initialize the requirements for the analysis: domain and events */
-            TmfAnalysisRequirement eventsReq = new TmfAnalysisEventRequirement(requiredEvents, PriorityLevel.MANDATORY);
+            TmfAbstractAnalysisRequirement eventsReq = new TmfAnalysisEventRequirement(requiredEvents, PriorityLevel.MANDATORY);
             /*
              * In order to have these events, the libc wrapper with probes should be
              * loaded

diff --git a/lttng/org.eclipse.tracecompass.lttng2.ust.ui/src/org/eclipse/tracecompass/internal/lttng2/ust/ui/analysis/callstack/LttngUstCallStackAnalysisRequirement.java b/lttng/org.eclipse.tracecompass.lttng2.ust.ui/src/org/eclipse/tracecompass/internal/lttng2/ust/ui/analysis/callstack/LttngUstCallStackAnalysisRequirement.java
index 3e0ee700b26f4f84fafcaa96ba64e7e27f2bbff3..2e9165a597904db9bd86bcfa22942c15db587fab 100644 (file)
--- a/lttng/org.eclipse.tracecompass.lttng2.ust.ui/src/org/eclipse/tracecompass/internal/lttng2/ust/ui/analysis/callstack/LttngUstCallStackAnalysisRequirement.java
+++ b/lttng/org.eclipse.tracecompass.lttng2.ust.ui/src/org/eclipse/tracecompass/internal/lttng2/ust/ui/analysis/callstack/LttngUstCallStackAnalysisRequirement.java
@@ -17,7 +17,7 @@ import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.NonNullByDefault;
 import org.eclipse.tracecompass.lttng2.ust.core.trace.layout.ILttngUstEventLayout;
 import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisEventFieldRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
 import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfCompositeAnalysisRequirement;
 
 import com.google.common.collect.ImmutableSet;
@@ -43,7 +43,7 @@ public class LttngUstCallStackAnalysisRequirement extends TmfCompositeAnalysisRe
         addInformation(nullToEmptyString(Messages.LttnUstCallStackAnalysisModule_EventsLoadingInformation));
     }
 
-    private static Collection<TmfAnalysisRequirement> getSubRequirements(ILttngUstEventLayout layout) {
+    private static Collection<TmfAbstractAnalysisRequirement> getSubRequirements(ILttngUstEventLayout layout) {
         Set<@NonNull String> requiredEventsFields = ImmutableSet.of(
                 layout.contextProcname(),
                 layout.contextVtid());
@@ -54,12 +54,12 @@ public class LttngUstCallStackAnalysisRequirement extends TmfCompositeAnalysisRe
                 requiredEventsFields,
                 PriorityLevel.MANDATORY);
 
-        TmfAnalysisRequirement exitReq = new TmfAnalysisEventFieldRequirement(
+        TmfAbstractAnalysisRequirement exitReq = new TmfAnalysisEventFieldRequirement(
                 layout.eventCygProfileFuncExit(),
                 requiredEventsFields,
                 PriorityLevel.MANDATORY);
 
-        TmfAnalysisRequirement cygProfile = new TmfCompositeAnalysisRequirement(ImmutableSet.of(entryReq, exitReq), PriorityLevel.MANDATORY);
+        TmfAbstractAnalysisRequirement cygProfile = new TmfCompositeAnalysisRequirement(ImmutableSet.of(entryReq, exitReq), PriorityLevel.MANDATORY);
 
         // Requirement for the cyg_profile_fast events
         entryReq = new TmfAnalysisEventFieldRequirement(
@@ -71,7 +71,7 @@ public class LttngUstCallStackAnalysisRequirement extends TmfCompositeAnalysisRe
                 layout.eventCygProfileFastFuncExit(),
                 requiredEventsFields,
                 PriorityLevel.MANDATORY);
-        TmfAnalysisRequirement cygProfileFast = new TmfCompositeAnalysisRequirement(ImmutableSet.of(entryReq, exitReq), PriorityLevel.MANDATORY);
+        TmfAbstractAnalysisRequirement cygProfileFast = new TmfCompositeAnalysisRequirement(ImmutableSet.of(entryReq, exitReq), PriorityLevel.MANDATORY);
 
         return ImmutableSet.of(cygProfile, cygProfileFast);
     }

diff --git a/lttng/org.eclipse.tracecompass.lttng2.ust.ui/src/org/eclipse/tracecompass/lttng2/ust/ui/analysis/callstack/LttngUstCallStackAnalysis.java b/lttng/org.eclipse.tracecompass.lttng2.ust.ui/src/org/eclipse/tracecompass/lttng2/ust/ui/analysis/callstack/LttngUstCallStackAnalysis.java
index e533d135770c49f338eb6f0f503405e43bfb05f7..c51cd4f19852cf4f2305a727f6bdaa927ecefd33 100644 (file)
--- a/lttng/org.eclipse.tracecompass.lttng2.ust.ui/src/org/eclipse/tracecompass/lttng2/ust/ui/analysis/callstack/LttngUstCallStackAnalysis.java
+++ b/lttng/org.eclipse.tracecompass.lttng2.ust.ui/src/org/eclipse/tracecompass/lttng2/ust/ui/analysis/callstack/LttngUstCallStackAnalysis.java
@@ -23,7 +23,7 @@ import org.eclipse.tracecompass.internal.lttng2.ust.core.callstack.LttngUstCallS
 import org.eclipse.tracecompass.internal.lttng2.ust.ui.analysis.callstack.LttngUstCallStackAnalysisRequirement;
 import org.eclipse.tracecompass.lttng2.ust.core.trace.LttngUstTrace;
 import org.eclipse.tracecompass.lttng2.ust.core.trace.layout.ILttngUstEventLayout;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
 import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
 import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;
 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
@@ -39,7 +39,7 @@ import com.google.common.collect.ImmutableSet;
  */
 public class LttngUstCallStackAnalysis extends AbstractCallStackAnalysis {
 
-    private @Nullable Set<@NonNull TmfAnalysisRequirement> fAnalysisRequirements = null;
+    private @Nullable Set<@NonNull TmfAbstractAnalysisRequirement> fAnalysisRequirements = null;
 
     /**
      * @since 1.0
@@ -63,9 +63,9 @@ public class LttngUstCallStackAnalysis extends AbstractCallStackAnalysis {
     }
 
     @Override
-    public @NonNull Iterable<@NonNull TmfAnalysisRequirement> getAnalysisRequirements() {
+    public @NonNull Iterable<@NonNull TmfAbstractAnalysisRequirement> getAnalysisRequirements() {
 
-        Set<@NonNull TmfAnalysisRequirement> requirements = fAnalysisRequirements;
+        Set<@NonNull TmfAbstractAnalysisRequirement> requirements = fAnalysisRequirements;
         if (requirements == null) {
             LttngUstTrace trace = getTrace();
             ILttngUstEventLayout layout = ILttngUstEventLayout.DEFAULT_LAYOUT;

diff --git a/tmf/org.eclipse.tracecompass.tmf.analysis.xml.core/src/org/eclipse/tracecompass/internal/tmf/analysis/xml/core/module/TmfAnalysisModuleHelperXml.java b/tmf/org.eclipse.tracecompass.tmf.analysis.xml.core/src/org/eclipse/tracecompass/internal/tmf/analysis/xml/core/module/TmfAnalysisModuleHelperXml.java
index 84bcf32a537f2c2421148ac52a7d34e3cf78f265..b955a1a5195be67e66dfb562d6ef312734624511 100644 (file)
--- a/tmf/org.eclipse.tracecompass.tmf.analysis.xml.core/src/org/eclipse/tracecompass/internal/tmf/analysis/xml/core/module/TmfAnalysisModuleHelperXml.java
+++ b/tmf/org.eclipse.tracecompass.tmf.analysis.xml.core/src/org/eclipse/tracecompass/internal/tmf/analysis/xml/core/module/TmfAnalysisModuleHelperXml.java
@@ -25,7 +25,7 @@ import org.eclipse.tracecompass.internal.tmf.analysis.xml.core.stateprovider.Xml
 import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
 import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModuleHelper;
 import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisManager;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
 import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
 import org.eclipse.tracecompass.tmf.core.project.model.ITmfPropertiesProvider;
 import org.eclipse.tracecompass.tmf.core.project.model.TmfTraceType;
@@ -169,7 +169,7 @@ public class TmfAnalysisModuleHelperXml implements IAnalysisModuleHelper, ITmfPr
     }
 
     @Override
-    public Iterable<TmfAnalysisRequirement> getAnalysisRequirements() {
+    public Iterable<TmfAbstractAnalysisRequirement> getAnalysisRequirements() {
         return Collections.EMPTY_SET;
     }
 

diff --git a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/AnalysisModuleHelperTest.java b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/AnalysisModuleHelperTest.java
index 9957260fd26e4afd82697417c3b28cc8eb1e4b82..d4a0d903813c9419e060c30b6c9ec95ed160febe 100644 (file)
--- a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/AnalysisModuleHelperTest.java
+++ b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/AnalysisModuleHelperTest.java
@@ -28,7 +28,7 @@ import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
 import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModuleHelper;
 import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisManager;
 import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisModuleHelperConfigElement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
 import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
 import org.eclipse.tracecompass.tmf.core.tests.shared.TmfTestTrace;
 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
@@ -354,8 +354,8 @@ public class AnalysisModuleHelperTest {
      */
     @Test
     public void testGetRequirements() {
-        Iterable<TmfAnalysisRequirement> requirements = fReqModule.getAnalysisRequirements();
-        Set<TmfAnalysisRequirement> expected = ImmutableSet.of(
+        Iterable<TmfAbstractAnalysisRequirement> requirements = fReqModule.getAnalysisRequirements();
+        Set<TmfAbstractAnalysisRequirement> expected = ImmutableSet.of(
                 AnalysisRequirementFactory.REQUIREMENT_1,
                 AnalysisRequirementFactory.REQUIREMENT_3);
 

diff --git a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisEventFieldRequirementTest.java b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisEventFieldRequirementTest.java
index 3b306f6f79e3c26d25ae1cf326db93037803dd10..07c069e72fa553b1c8a12bc9ff0c6753597fbbc9 100644 (file)
--- a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisEventFieldRequirementTest.java
+++ b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisEventFieldRequirementTest.java
@@ -19,8 +19,8 @@ import java.util.Set;
 
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisEventFieldRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.PriorityLevel;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement.PriorityLevel;
 import org.eclipse.tracecompass.tmf.core.event.ITmfEventField;
 import org.eclipse.tracecompass.tmf.core.event.ITmfEventType;
 import org.eclipse.tracecompass.tmf.core.trace.ITmfTraceWithPreDefinedEvents;
@@ -115,7 +115,7 @@ public class AnalysisEventFieldRequirementTest {
     @Test
     public void testOptionalRequirements() {
         /* Test optional requirement */
-        TmfAnalysisRequirement req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1));
+        TmfAbstractAnalysisRequirement req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1));
         assertTrue(req.test(trace));
 
         req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1, EVENT1_FIELD2));
@@ -137,7 +137,7 @@ public class AnalysisEventFieldRequirementTest {
     @Test
     public void testMandatoryRequirements() {
         /* Test mandatory requirement */
-        TmfAnalysisRequirement req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1), PriorityLevel.MANDATORY);
+        TmfAbstractAnalysisRequirement req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1), PriorityLevel.MANDATORY);
         assertTrue(req.test(trace));
 
         req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1, EVENT1_FIELD2), PriorityLevel.MANDATORY);
@@ -169,7 +169,7 @@ public class AnalysisEventFieldRequirementTest {
         /* A simple trace with no pre-defined events */
         TmfTrace traceNoEvents = new TmfTraceStub();
 
-        TmfAnalysisRequirement req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1), PriorityLevel.MANDATORY);
+        TmfAbstractAnalysisRequirement req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1), PriorityLevel.MANDATORY);
         assertTrue(req.test(traceNoEvents));
 
         req = new TmfAnalysisEventFieldRequirement(EVENT1, ImmutableSet.of(EVENT1_FIELD1), PriorityLevel.OPTIONAL);

diff --git a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisEventRequirementTest.java b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisEventRequirementTest.java
index 942730ceefb41a102195c255b1be7f986289c00f..2808a7e9dfbb795c49ffefd745a53592be92f059 100644 (file)
--- a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisEventRequirementTest.java
+++ b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisEventRequirementTest.java
@@ -17,8 +17,8 @@ import java.util.Set;
 
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisEventRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.PriorityLevel;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement.PriorityLevel;
 import org.eclipse.tracecompass.tmf.core.event.ITmfEventField;
 import org.eclipse.tracecompass.tmf.core.event.ITmfEventType;
 import org.eclipse.tracecompass.tmf.core.trace.ITmfTraceWithPreDefinedEvents;
@@ -91,7 +91,7 @@ public class AnalysisEventRequirementTest {
     @Test
     public void testOptionalRequirements() {
         /* Test optional requirement */
-        TmfAnalysisRequirement req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1));
+        TmfAbstractAnalysisRequirement req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1));
         assertTrue(req.test(fTrace));
 
         req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1, EVENT3));
@@ -108,7 +108,7 @@ public class AnalysisEventRequirementTest {
     @Test
     public void testMandatoryRequirements() {
         /* Test mandatory requirement */
-        TmfAnalysisRequirement req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1), PriorityLevel.MANDATORY);
+        TmfAbstractAnalysisRequirement req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1), PriorityLevel.MANDATORY);
         assertTrue(req.test(fTrace));
 
         req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1, EVENT2), PriorityLevel.MANDATORY);
@@ -131,7 +131,7 @@ public class AnalysisEventRequirementTest {
         /* A simple trace with no pre-defined events */
         TmfTrace traceNoEvents = new TmfTraceStub();
 
-        TmfAnalysisRequirement req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1, EVENT3), PriorityLevel.MANDATORY);
+        TmfAbstractAnalysisRequirement req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1, EVENT3), PriorityLevel.MANDATORY);
         assertTrue(req.test(traceNoEvents));
 
         req = new TmfAnalysisEventRequirement(ImmutableSet.of(EVENT1, EVENT2), PriorityLevel.OPTIONAL);

diff --git a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisRequirementTest.java b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisRequirementTest.java
index cba7c9defae79e3f8fb8a5b2b79a271d3bd2cfe1..aa4d4e1f9d2b216c4e6aa74096c4967b51b5743d 100644 (file)
--- a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisRequirementTest.java
+++ b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/AnalysisRequirementTest.java
@@ -20,14 +20,15 @@ import java.util.Collections;
 import java.util.Set;
 
 import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.PriorityLevel;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement.PriorityLevel;
+import org.eclipse.tracecompass.tmf.tests.stubs.analysis.AnalysisRequirementFactory;
 import org.junit.Test;
 
 import com.google.common.collect.ImmutableSet;
 
 /**
- * Test suite for the {@link TmfAnalysisRequirement} class.
+ * Test suite for the {@link TmfAbstractAnalysisRequirement} class.
  *
  * @author Guilliano Molaire
  * @author Mathieu Rail
@@ -43,13 +44,12 @@ public class AnalysisRequirementTest {
     private static final @NonNull String INFO_B = "This is another information.";
 
     /**
-     * Test the {@link TmfAnalysisRequirement#addInformation} and the
-     * {@link TmfAnalysisRequirement#getInformation} methods.
+     * Test the {@link TmfAbstractAnalysisRequirement#addInformation(String)} and the
+     * {@link TmfAbstractAnalysisRequirement#getInformation()} methods.
      */
     @Test
     public void testAddAndGetInformation() {
-        TmfAnalysisRequirement requirement = new TmfAnalysisRequirement(Collections.EMPTY_SET, PriorityLevel.OPTIONAL);
-
+        TmfAbstractAnalysisRequirement requirement = new AnalysisRequirementFactory.TmfRequirementStub(Collections.EMPTY_SET, PriorityLevel.OPTIONAL);
         requirement.addInformation(INFO_A);
         requirement.addInformation(INFO_B);
         requirement.addInformation(INFO_B);
@@ -63,34 +63,35 @@ public class AnalysisRequirementTest {
     }
 
     /**
-     * Test the {@link TmfAnalysisRequirement#getValueLevel} method.
+     * Test the {@link TmfAbstractAnalysisRequirement#getPriorityLevel()} method.
      */
     @Test
     public void testGetValueLevel() {
         /* Optional requirement */
-        TmfAnalysisRequirement requirement = new TmfAnalysisRequirement(Collections.EMPTY_SET, PriorityLevel.OPTIONAL);
+        TmfAbstractAnalysisRequirement requirement = new AnalysisRequirementFactory.TmfRequirementStub(Collections.EMPTY_SET, PriorityLevel.OPTIONAL);
         assertEquals(PriorityLevel.OPTIONAL, requirement.getPriorityLevel());
 
         /* All or nothing */
-        requirement = new TmfAnalysisRequirement(Collections.EMPTY_SET, PriorityLevel.ALL_OR_NOTHING);
+        requirement = new AnalysisRequirementFactory.TmfRequirementStub(Collections.EMPTY_SET, PriorityLevel.ALL_OR_NOTHING);
         assertEquals(PriorityLevel.ALL_OR_NOTHING, requirement.getPriorityLevel());
 
         /* At least one */
-        requirement = new TmfAnalysisRequirement(Collections.EMPTY_SET, PriorityLevel.AT_LEAST_ONE);
+        requirement = new AnalysisRequirementFactory.TmfRequirementStub(Collections.EMPTY_SET, PriorityLevel.AT_LEAST_ONE);
         assertEquals(PriorityLevel.AT_LEAST_ONE, requirement.getPriorityLevel());
 
         /* Mandatory */
-        requirement = new TmfAnalysisRequirement(Collections.EMPTY_SET, PriorityLevel.MANDATORY);
+        requirement = new AnalysisRequirementFactory.TmfRequirementStub(Collections.EMPTY_SET, PriorityLevel.MANDATORY);
         assertEquals(PriorityLevel.MANDATORY, requirement.getPriorityLevel());
     }
 
     /**
-     * Test the {@link TmfAnalysisRequirement#getValues()} method
+     * Test the {@link TmfAbstractAnalysisRequirement#getValues()} method
      */
     @Test
     public void testGetValues() {
         ImmutableSet<@NonNull String> values = ImmutableSet.of(VALUE_A, VALUE_B);
-        TmfAnalysisRequirement requirement = new TmfAnalysisRequirement(values, PriorityLevel.OPTIONAL);
+
+        TmfAbstractAnalysisRequirement requirement = new AnalysisRequirementFactory.TmfRequirementStub(values, PriorityLevel.OPTIONAL);
         assertEquals(values, requirement.getValues());
     }
 

diff --git a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/CompositeRequirementTest.java b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/CompositeRequirementTest.java
index 5c1dfdcec0873d622762a844fe767be6f4c1a707..a4771b45efbf0129fbb94eb75326c2c8f29c9043 100644 (file)
--- a/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/CompositeRequirementTest.java
+++ b/tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/analysis/requirements/CompositeRequirementTest.java
@@ -16,8 +16,8 @@ import static org.junit.Assert.assertTrue;
 import java.util.Collections;
 
 import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.PriorityLevel;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement.PriorityLevel;
 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
 import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfTraceStub;
 import org.junit.Before;
@@ -34,28 +34,28 @@ import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfCompositeAnaly
  */
 public class CompositeRequirementTest {
 
-    private static final @NonNull TmfAnalysisRequirement FALSE_REQ1 = new TmfAnalysisRequirement(Collections.EMPTY_SET, PriorityLevel.MANDATORY) {
+    private static final @NonNull TmfAbstractAnalysisRequirement FALSE_REQ1 = new TmfAbstractAnalysisRequirement(Collections.EMPTY_SET, PriorityLevel.MANDATORY) {
         @Override
         public boolean test(ITmfTrace trace) {
             return false;
         }
     };
 
-    private static final @NonNull TmfAnalysisRequirement FALSE_REQ2 = new TmfAnalysisRequirement(Collections.EMPTY_SET, PriorityLevel.MANDATORY) {
+    private static final @NonNull TmfAbstractAnalysisRequirement FALSE_REQ2 = new TmfAbstractAnalysisRequirement(Collections.EMPTY_SET, PriorityLevel.MANDATORY) {
         @Override
         public boolean test(ITmfTrace trace) {
             return false;
         }
     };
 
-    private static final @NonNull TmfAnalysisRequirement TRUE_REQ1 = new TmfAnalysisRequirement(Collections.EMPTY_SET, PriorityLevel.MANDATORY) {
+    private static final @NonNull TmfAbstractAnalysisRequirement TRUE_REQ1 = new TmfAbstractAnalysisRequirement(Collections.EMPTY_SET, PriorityLevel.MANDATORY) {
         @Override
         public boolean test(ITmfTrace trace) {
             return true;
         }
     };
 
-    private static final @NonNull TmfAnalysisRequirement TRUE_REQ2 = new TmfAnalysisRequirement(Collections.EMPTY_SET, PriorityLevel.MANDATORY) {
+    private static final @NonNull TmfAbstractAnalysisRequirement TRUE_REQ2 = new TmfAbstractAnalysisRequirement(Collections.EMPTY_SET, PriorityLevel.MANDATORY) {
         @Override
         public boolean test(ITmfTrace trace) {
             return true;
@@ -80,7 +80,7 @@ public class CompositeRequirementTest {
         ITmfTrace trace = fTrace;
         assertNotNull(trace);
 
-        TmfAnalysisRequirement req = new TmfCompositeAnalysisRequirement(ImmutableSet.of(TRUE_REQ1), PriorityLevel.MANDATORY);
+        TmfAbstractAnalysisRequirement req = new TmfCompositeAnalysisRequirement(ImmutableSet.of(TRUE_REQ1), PriorityLevel.MANDATORY);
         assertTrue(req.test(trace));
 
         req = new TmfCompositeAnalysisRequirement(ImmutableSet.of(TRUE_REQ1, TRUE_REQ2), PriorityLevel.MANDATORY);
@@ -104,7 +104,7 @@ public class CompositeRequirementTest {
         ITmfTrace trace = fTrace;
         assertNotNull(trace);
 
-        TmfAnalysisRequirement req = new TmfCompositeAnalysisRequirement(ImmutableSet.of(TRUE_REQ1), PriorityLevel.AT_LEAST_ONE);
+        TmfAbstractAnalysisRequirement req = new TmfCompositeAnalysisRequirement(ImmutableSet.of(TRUE_REQ1), PriorityLevel.AT_LEAST_ONE);
         assertTrue(req.test(trace));
 
         req = new TmfCompositeAnalysisRequirement(ImmutableSet.of(TRUE_REQ1, TRUE_REQ2), PriorityLevel.AT_LEAST_ONE);
@@ -128,7 +128,7 @@ public class CompositeRequirementTest {
         ITmfTrace trace = fTrace;
         assertNotNull(trace);
 
-        TmfAnalysisRequirement req = new TmfCompositeAnalysisRequirement(ImmutableSet.of(TRUE_REQ1), PriorityLevel.ALL_OR_NOTHING);
+        TmfAbstractAnalysisRequirement req = new TmfCompositeAnalysisRequirement(ImmutableSet.of(TRUE_REQ1), PriorityLevel.ALL_OR_NOTHING);
         assertTrue(req.test(trace));
 
         req = new TmfCompositeAnalysisRequirement(ImmutableSet.of(TRUE_REQ1, TRUE_REQ2), PriorityLevel.ALL_OR_NOTHING);
@@ -152,7 +152,7 @@ public class CompositeRequirementTest {
         ITmfTrace trace = fTrace;
         assertNotNull(trace);
 
-        TmfAnalysisRequirement req = new TmfCompositeAnalysisRequirement(ImmutableSet.of(TRUE_REQ1), PriorityLevel.OPTIONAL);
+        TmfAbstractAnalysisRequirement req = new TmfCompositeAnalysisRequirement(ImmutableSet.of(TRUE_REQ1), PriorityLevel.OPTIONAL);
         assertTrue(req.test(trace));
 
         req = new TmfCompositeAnalysisRequirement(ImmutableSet.of(TRUE_REQ1, TRUE_REQ2), PriorityLevel.OPTIONAL);

diff --git a/tmf/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/AnalysisModuleTestHelper.java b/tmf/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/AnalysisModuleTestHelper.java
index e34e7fb379010680f9a00d67a82cfae3d452c918..13ddd455e20b09f033d634143820bb9dc0ed4a11 100644 (file)
--- a/tmf/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/AnalysisModuleTestHelper.java
+++ b/tmf/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/AnalysisModuleTestHelper.java
@@ -19,7 +19,7 @@ import org.eclipse.core.runtime.Platform;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
 import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModuleHelper;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
 import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
 import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfTraceStub;
@@ -148,7 +148,7 @@ public class AnalysisModuleTestHelper implements IAnalysisModuleHelper {
     }
 
     @Override
-    public Iterable<TmfAnalysisRequirement> getAnalysisRequirements() {
+    public Iterable<TmfAbstractAnalysisRequirement> getAnalysisRequirements() {
         switch (fModule) {
         case TEST:
             return ImmutableList.of(

diff --git a/tmf/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/AnalysisRequirementFactory.java b/tmf/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/AnalysisRequirementFactory.java
index a778f0e038ead66e9f0d7c825a3ec5e7518235d5..ada5e5b5511bf77bfa8d1bb6fc52548d3486ca69 100644 (file)
--- a/tmf/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/AnalysisRequirementFactory.java
+++ b/tmf/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/AnalysisRequirementFactory.java
@@ -12,11 +12,14 @@
 
 package org.eclipse.tracecompass.tmf.tests.stubs.analysis;
 
+import java.util.Collection;
 import java.util.Set;
 
+import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.PriorityLevel;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement.PriorityLevel;
+import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
 
 import com.google.common.collect.ImmutableSet;
 
@@ -27,7 +30,8 @@ import com.google.common.collect.ImmutableSet;
 @NonNullByDefault
 public final class AnalysisRequirementFactory {
 
-    private AnalysisRequirementFactory() {}
+    private AnalysisRequirementFactory() {
+    }
 
     public static final String REQUIREMENT_VALUE_1 = "value1";
     public static final String REQUIREMENT_VALUE_2 = "value2";
@@ -39,25 +43,32 @@ public final class AnalysisRequirementFactory {
             REQUIREMENT_VALUE_1,
             REQUIREMENT_VALUE_2,
             REQUIREMENT_VALUE_3,
-            REQUIREMENT_VALUE_5
-            );
+            REQUIREMENT_VALUE_5);
 
     public static final Set<String> REQUIREMENT_VALUES_2 = ImmutableSet.of(
             REQUIREMENT_VALUE_2,
-            REQUIREMENT_VALUE_3
-            );
+            REQUIREMENT_VALUE_3);
 
     public static final Set<String> REQUIREMENT_VALUES_3 = ImmutableSet.of(
             REQUIREMENT_VALUE_3,
             REQUIREMENT_VALUE_4,
-            REQUIREMENT_VALUE_5
-            );
-
-    public static final TmfAnalysisRequirement REQUIREMENT_1 =
-            new TmfAnalysisRequirement(REQUIREMENT_VALUES_1, PriorityLevel.MANDATORY);
-    public static final TmfAnalysisRequirement REQUIREMENT_2 =
-            new TmfAnalysisRequirement(REQUIREMENT_VALUES_2, PriorityLevel.MANDATORY);
-    public static final TmfAnalysisRequirement REQUIREMENT_3 =
-            new TmfAnalysisRequirement(REQUIREMENT_VALUES_3, PriorityLevel.MANDATORY);
+            REQUIREMENT_VALUE_5);
+
+    public static class TmfRequirementStub extends TmfAbstractAnalysisRequirement {
+
+        public TmfRequirementStub(Collection<@NonNull String> values, PriorityLevel level) {
+            super(values, level);
+        }
+
+        @Override
+        @NonNullByDefault({})
+        public boolean test(ITmfTrace arg0) {
+            return true;
+        }
+    }
+
+    public static final TmfAbstractAnalysisRequirement REQUIREMENT_1 = new TmfRequirementStub(REQUIREMENT_VALUES_1, PriorityLevel.MANDATORY);
+    public static final TmfAbstractAnalysisRequirement REQUIREMENT_2 = new TmfRequirementStub(REQUIREMENT_VALUES_2, PriorityLevel.MANDATORY);
+    public static final TmfAbstractAnalysisRequirement REQUIREMENT_3 = new TmfRequirementStub(REQUIREMENT_VALUES_3, PriorityLevel.MANDATORY);
 
 }

diff --git a/tmf/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/TestRequirementAnalysis.java b/tmf/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/TestRequirementAnalysis.java
index 08ca6e51b048450d49523c56e0c7d66a9601d21e..74f0c6bd6f35f437fd1144768982c4f5f4005df0 100644 (file)
--- a/tmf/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/TestRequirementAnalysis.java
+++ b/tmf/org.eclipse.tracecompass.tmf.core.tests/stubs/org/eclipse/tracecompass/tmf/tests/stubs/analysis/TestRequirementAnalysis.java
@@ -17,7 +17,7 @@ import java.util.Set;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.tracecompass.tmf.core.analysis.TmfAbstractAnalysisModule;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
 import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
 import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfTraceStub;
@@ -64,8 +64,8 @@ public class TestRequirementAnalysis extends TmfAbstractAnalysisModule {
     }
 
     @Override
-    public Iterable<TmfAnalysisRequirement> getAnalysisRequirements() {
-        Set<TmfAnalysisRequirement> requirements = ImmutableSet.of(
+    public Iterable<TmfAbstractAnalysisRequirement> getAnalysisRequirements() {
+        Set<TmfAbstractAnalysisRequirement> requirements = ImmutableSet.of(
                 AnalysisRequirementFactory.REQUIREMENT_1,
                 AnalysisRequirementFactory.REQUIREMENT_3);
 

diff --git a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/TmfAbstractAnalysisModule.java b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/TmfAbstractAnalysisModule.java
index 46fc16bb0f9ab31777fb8ffb67cd316f65dde869..13ea189a9288f38aabbbc723f26f59172873d324 100644 (file)
--- a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/TmfAbstractAnalysisModule.java
+++ b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/TmfAbstractAnalysisModule.java
@@ -36,7 +36,7 @@ import org.eclipse.osgi.util.NLS;
 import org.eclipse.tracecompass.common.core.NonNullUtils;
 import org.eclipse.tracecompass.internal.tmf.core.Activator;
 import org.eclipse.tracecompass.internal.tmf.core.TmfCoreTracer;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
 import org.eclipse.tracecompass.tmf.core.component.TmfComponent;
 import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
 import org.eclipse.tracecompass.tmf.core.project.model.ITmfPropertiesProvider;
@@ -210,7 +210,7 @@ public abstract class TmfAbstractAnalysisModule extends TmfComponent
 
     @Override
     public boolean canExecute(ITmfTrace trace) {
-        for (TmfAnalysisRequirement requirement : getAnalysisRequirements()) {
+        for (TmfAbstractAnalysisRequirement requirement : getAnalysisRequirements()) {
             if (!requirement.test(trace)) {
                 return false;
             }
@@ -504,7 +504,7 @@ public abstract class TmfAbstractAnalysisModule extends TmfComponent
     protected String getTraceCannotExecuteHelpText(ITmfTrace trace) {
         StringBuilder builder = new StringBuilder();
         builder.append(NLS.bind(Messages.TmfAbstractAnalysisModule_AnalysisCannotExecute, getName()));
-        for (TmfAnalysisRequirement requirement : getAnalysisRequirements()) {
+        for (TmfAbstractAnalysisRequirement requirement : getAnalysisRequirements()) {
             if (!requirement.test(trace)) {
                 builder.append("\n\n"); //$NON-NLS-1$
                 builder.append(NLS.bind(Messages.TmfAnalysis_RequirementNotFulfilled, requirement.getPriorityLevel()));
@@ -535,7 +535,7 @@ public abstract class TmfAbstractAnalysisModule extends TmfComponent
     }
 
     @Override
-    public Iterable<@NonNull TmfAnalysisRequirement> getAnalysisRequirements() {
+    public Iterable<@NonNull TmfAbstractAnalysisRequirement> getAnalysisRequirements() {
         return Collections.EMPTY_SET;
     }
 

diff --git a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/TmfAnalysisModuleHelperConfigElement.java b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/TmfAnalysisModuleHelperConfigElement.java
index 716483b14ca765e1e7de55c6212742418f93b936..9a710a5bff3aa8c959897c76451360b535771aac 100644 (file)
--- a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/TmfAnalysisModuleHelperConfigElement.java
+++ b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/TmfAnalysisModuleHelperConfigElement.java
@@ -24,7 +24,7 @@ import org.eclipse.core.runtime.InvalidRegistryObjectException;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.tracecompass.internal.tmf.core.Activator;
 import org.eclipse.tracecompass.internal.tmf.core.analysis.TmfAnalysisModuleSourceConfigElement;
-import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAbstractAnalysisRequirement;
 import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
 import org.eclipse.tracecompass.tmf.core.project.model.TmfTraceType;
 import org.eclipse.tracecompass.tmf.core.project.model.TraceTypeHelper;
@@ -154,7 +154,7 @@ public class TmfAnalysisModuleHelperConfigElement implements IAnalysisModuleHelp
     }
 
     @Override
-    public Iterable<TmfAnalysisRequirement> getAnalysisRequirements() {
+    public Iterable<TmfAbstractAnalysisRequirement> getAnalysisRequirements() {
         IAnalysisModule module = createModule();
         if (module != null) {
             return module.getAnalysisRequirements();

diff --git a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/IAnalysisRequirementProvider.java b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/IAnalysisRequirementProvider.java
index 707418d13742eb4957e047dcda34cc31ad7cf5b6..241b002f35c7792e92b1c84888d7ced6d4247494 100644 (file)
--- a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/IAnalysisRequirementProvider.java
+++ b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/IAnalysisRequirementProvider.java
@@ -28,5 +28,5 @@ public interface IAnalysisRequirementProvider {
      *
      * @return List of requirement
      */
-    Iterable<TmfAnalysisRequirement> getAnalysisRequirements();
+    Iterable<TmfAbstractAnalysisRequirement> getAnalysisRequirements();
 }

diff --git a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAbstractAnalysisRequirement.java b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAbstractAnalysisRequirement.java
new file mode 100644 (file)
index 0000000..dee4876
--- /dev/null
+++ b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAbstractAnalysisRequirement.java
@@ -0,0 +1,119 @@
+/*******************************************************************************
+ * Copyright (c) 2014, 2016 École Polytechnique de Montréal
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v1.0 which
+ * accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.tmf.core.analysis.requirements;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.function.Predicate;
+
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
+
+import com.google.common.collect.ImmutableSet;
+
+/**
+ * This class represents a requirement that a trace must verify for an analysis
+ * to be able to run on it. This class is the base class for more specific
+ * requirement classes that will implement what to do with the values specified.
+ *
+ * A requirement has a priority level which will determine how the values will
+ * be tested on the trace and what the result should be depending on the
+ * presence or absence of those values.
+ *
+ * Moreover, useful information that can not be leveled with a priority but are
+ * important for the proper execution of an analysis can be added.
+ *
+ * @author Guilliano Molaire
+ * @author Mathieu Rail
+ * @author Geneviève Bastien
+ * @since 2.0
+ */
+public abstract class TmfAbstractAnalysisRequirement implements Predicate<ITmfTrace> {
+
+    private final Set<@NonNull String> fValues = new HashSet<>();
+    private final Set<@NonNull String> fInformation = new HashSet<>();
+    private final PriorityLevel fLevel;
+
+    /**
+     * The possible level for a requirement.
+     */
+    public enum PriorityLevel {
+        /** The value could be absent and the analysis would still work */
+        OPTIONAL,
+        /**
+         * The values can be absent, but if one is present, then all should be
+         * present
+         */
+        ALL_OR_NOTHING,
+        /** At least one of the values must be present at runtime */
+        AT_LEAST_ONE,
+        /** The value must be present at runtime (for the analysis) */
+        MANDATORY
+    }
+
+    /**
+     * Constructor. Instantiate a requirement object with a list of values of
+     * the same level
+     *
+     * @param values
+     *            All the values associated with that type
+     * @param level
+     *            A level associated with all the values
+     */
+    public TmfAbstractAnalysisRequirement(Collection<String> values, PriorityLevel level) {
+        fLevel = level;
+        fValues.addAll(values);
+    }
+
+    /**
+     * Adds an information about the requirement.
+     *
+     * @param information
+     *            The information to be added
+     */
+    public void addInformation(String information) {
+        fInformation.add(information);
+    }
+
+    /**
+     * Gets all the values associated with the requirement.
+     *
+     * @return Set containing the values
+     */
+    public Set<String> getValues() {
+        synchronized (fValues) {
+            return ImmutableSet.copyOf(fValues);
+        }
+    }
+
+    /**
+     * Gets information about the requirement.
+     *
+     * @return The set of all the information
+     */
+    public Set<@NonNull String> getInformation() {
+        return fInformation;
+    }
+
+    /**
+     * Gets the level of this requirement
+     *
+     * @return The level of the requirement
+     */
+    public PriorityLevel getPriorityLevel() {
+        return fLevel;
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName() + ": " + fValues; //$NON-NLS-1$
+    }
+}

diff --git a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisEventFieldRequirement.java b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisEventFieldRequirement.java
index f3b9005773b2952abd9333d16fe69af6efc0ebf7..d9acbf8fce0b26dd0c812b515d8e42ab407f825e 100644 (file)
--- a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisEventFieldRequirement.java
+++ b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisEventFieldRequirement.java
@@ -26,7 +26,7 @@ import com.google.common.collect.Multimap;
  * @author Bernd Hufmann
  * @since 2.0
  */
-public class TmfAnalysisEventFieldRequirement extends TmfAnalysisRequirement {
+public class TmfAnalysisEventFieldRequirement extends TmfAbstractAnalysisRequirement {
 
     /** The event name of the event containing the mandatory fields */
     private String fEventName;

diff --git a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisEventRequirement.java b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisEventRequirement.java
index 2424082f7c9abdbeaf73c345f14b5a2d3f601d24..59ec2a6a798d28d75346191f49c4a6b5b5d7d0b9 100644 (file)
--- a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisEventRequirement.java
+++ b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisEventRequirement.java
@@ -23,7 +23,7 @@ import org.eclipse.tracecompass.tmf.core.trace.TmfEventTypeCollectionHelper;
  * @author Geneviève Bastien
  * @since 2.0
  */
-public class TmfAnalysisEventRequirement extends TmfAnalysisRequirement {
+public class TmfAnalysisEventRequirement extends TmfAbstractAnalysisRequirement {
 
     /**
      * Constructor for an optional requirement

diff --git a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisRequirement.java b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisRequirement.java
deleted file mode 100644 (file)
index b1d20fb..0000000
--- a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfAnalysisRequirement.java
+++ /dev/null
@@ -1,131 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2014, 2016 École Polytechnique de Montréal
- *
- * All rights reserved. This program and the accompanying materials are
- * made available under the terms of the Eclipse Public License v1.0 which
- * accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *******************************************************************************/
-
-package org.eclipse.tracecompass.tmf.core.analysis.requirements;
-
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.function.Predicate;
-
-import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
-
-import com.google.common.collect.ImmutableSet;
-
-/**
- * This class represents a requirement that a trace must verify for an analysis
- * to be able to run on it. This class is the base class for more specific
- * requirement classes that will implement what to do with the values specified.
- *
- * A requirement has a priority level which will determine how the values will
- * be tested on the trace and what the result should be depending on the
- * presence or absence of those values.
- *
- * Moreover, useful information that can not be leveled with a priority but are
- * important for the proper execution of an analysis can be added.
- *
- * @author Guilliano Molaire
- * @author Mathieu Rail
- * @author Geneviève Bastien
- * @since 2.0
- */
-public class TmfAnalysisRequirement implements Predicate<ITmfTrace> {
-
-    private final Set<@NonNull String> fValues = new HashSet<>();
-    private final Set<@NonNull String> fInformation = new HashSet<>();
-    private final PriorityLevel fLevel;
-
-    /**
-     * The possible level for a requirement.
-     */
-    public enum PriorityLevel {
-        /** The value could be absent and the analysis would still work */
-        OPTIONAL,
-        /**
-         * The values can be absent, but if one is present, then all should be
-         * present
-         */
-        ALL_OR_NOTHING,
-        /** At least one of the values must be present at runtime */
-        AT_LEAST_ONE,
-        /** The value must be present at runtime (for the analysis) */
-        MANDATORY
-    }
-
-    /**
-     * Constructor. Instantiate a requirement object with a list of values of
-     * the same level
-     *
-     * @param values
-     *            All the values associated with that type
-     * @param level
-     *            A level associated with all the values
-     */
-    public TmfAnalysisRequirement(Collection<String> values, PriorityLevel level) {
-        fLevel = level;
-        fValues.addAll(values);
-    }
-
-    /**
-     * Adds an information about the requirement.
-     *
-     * @param information
-     *            The information to be added
-     */
-    public void addInformation(String information) {
-        fInformation.add(information);
-    }
-
-    /**
-     * Gets all the values associated with the requirement.
-     *
-     * @return Set containing the values
-     */
-    public Set<String> getValues() {
-        synchronized (fValues) {
-            return ImmutableSet.copyOf(fValues);
-        }
-    }
-
-    /**
-     * Gets information about the requirement.
-     *
-     * @return The set of all the information
-     */
-    public Set<@NonNull String> getInformation() {
-        return fInformation;
-    }
-
-    /**
-     * Gets the level of this requirement
-     *
-     * @return The level of the requirement
-     */
-    public PriorityLevel getPriorityLevel() {
-        return fLevel;
-    }
-
-    /**
-     * Verifies whether a trace fulfills this requirement
-     *
-     * @param trace
-     *            The trace on which to check for this requirement
-     * @return True if the trace has all mandatory values of this requirement
-     */
-    @Override
-    public boolean test(ITmfTrace trace) {
-        return true;
-    }
-
-    @Override
-    public String toString() {
-        return getClass().getName() + ": " + fValues; //$NON-NLS-1$
-    }
-}

diff --git a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfCompositeAnalysisRequirement.java b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfCompositeAnalysisRequirement.java
index d58bb9531570442ef9e2073ad5fe5761d9f3fe9f..298a093272a7df5c8023df70b643ff5bca7c2a44 100644 (file)
--- a/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfCompositeAnalysisRequirement.java
+++ b/tmf/org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/tmf/core/analysis/requirements/TmfCompositeAnalysisRequirement.java
@@ -23,9 +23,9 @@ import com.google.common.collect.ImmutableList;
  * @author Geneviève Bastien
  * @since 2.0
  */
-public class TmfCompositeAnalysisRequirement extends TmfAnalysisRequirement {
+public class TmfCompositeAnalysisRequirement extends TmfAbstractAnalysisRequirement {
 
-    private final Collection<TmfAnalysisRequirement> fSubReqs;
+    private final Collection<TmfAbstractAnalysisRequirement> fSubReqs;
 
     /**
      * Constructor with sub requirements
@@ -35,14 +35,14 @@ public class TmfCompositeAnalysisRequirement extends TmfAnalysisRequirement {
      * @param level
      *            The level of this requirement
      */
-    public TmfCompositeAnalysisRequirement(Collection<TmfAnalysisRequirement> subRequirements, PriorityLevel level) {
+    public TmfCompositeAnalysisRequirement(Collection<TmfAbstractAnalysisRequirement> subRequirements, PriorityLevel level) {
         super(Collections.EMPTY_SET, level);
         fSubReqs = ImmutableList.copyOf(subRequirements);
     }
 
     @Override
     public boolean test(ITmfTrace trace) {
-        Collection<TmfAnalysisRequirement> subReqs = fSubReqs;
+        Collection<TmfAbstractAnalysisRequirement> subReqs = fSubReqs;
         if (subReqs.isEmpty()) {
             return true;
         }