The o.e.t.tmf.core.analysis package is getting crowded.
Change-Id: I2b8cc1cd9719733b260117787fa2865e03633c60
Signed-off-by: Geneviève Bastien <gbastien+lttng@versatic.net>
Reviewed-on: https://git.eclipse.org/r/68013
Reviewed-by: Hudson CI
Reviewed-by: Alexandre Montplaisir <alexmonthy@efficios.com>
Tested-by: Alexandre Montplaisir <alexmonthy@efficios.com>
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.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;
import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
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.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;
import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.lttng2.kernel.core.trace.LttngKernelTrace;
import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
-import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
import org.eclipse.tracecompass.tmf.core.tests.shared.TmfTestHelper;
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.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
import static org.junit.Assert.assertTrue;
import org.eclipse.tracecompass.lttng2.ust.core.analysis.memory.UstMemoryAnalysisModule;
-import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
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.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;
import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
import org.eclipse.tracecompass.lttng2.control.core.session.SessionConfigStrings;
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.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisRequirement.ValuePriorityLevel;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.ValuePriorityLevel;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;
import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
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.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
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;
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.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
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;
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2014 É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
- *
- * Contributors:
- * Guilliano Molaire - Initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.tracecompass.tmf.core.tests.analysis;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Set;
-
-import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisRequirementProvider;
-import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisRequirementHelper;
-import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisRequirement.ValuePriorityLevel;
-import org.eclipse.tracecompass.tmf.tests.stubs.analysis.AnalysisModuleTestHelper;
-import org.eclipse.tracecompass.tmf.tests.stubs.analysis.AnalysisRequirementFactory;
-import org.eclipse.tracecompass.tmf.tests.stubs.analysis.AnalysisModuleTestHelper.moduleStubEnum;
-import org.junit.Before;
-import org.junit.Test;
-
-import com.google.common.collect.Multimap;
-
-/**
- * Test suite for the {@link TmfAnalysisRequirementHelper} class
- */
-public class AnalysisRequirementHelperTest {
-
- private AnalysisModuleTestHelper fTestModuleHelper;
- private AnalysisModuleTestHelper fTestModuleHelper2;
-
- /**
- * Set up analysis modules
- */
- @Before
- public void setUpTest() {
- fTestModuleHelper = new AnalysisModuleTestHelper(moduleStubEnum.TEST);
- fTestModuleHelper2 = new AnalysisModuleTestHelper(moduleStubEnum.TEST2);
- }
-
- /**
- * Test suite for the
- * {@link TmfAnalysisRequirementHelper#getRequirementValues(IAnalysisRequirementProvider, String)}
- * method
- */
- @Test
- public void testGetRequirementValues() {
- /* Test with a supported type */
- String type = AnalysisRequirementFactory.REQUIREMENT_TYPE_1;
- Set<String> values = TmfAnalysisRequirementHelper.getRequirementValues(fTestModuleHelper, type);
- assertEquals(AnalysisRequirementFactory.REQUIREMENT_VALUES_1.size(), values.size());
-
- /* Test with a type not supported */
- type = AnalysisRequirementFactory.REQUIREMENT_TYPE_2;
- values = TmfAnalysisRequirementHelper.getRequirementValues(fTestModuleHelper, type);
- assertTrue(values.isEmpty());
- }
-
- /**
- * Test suite for the
- * {@link TmfAnalysisRequirementHelper#getRequirementValues(IAnalysisRequirementProvider, String, ValuePriorityLevel)}
- * method
- */
- @Test
- public void testGetRequirementValuesWithLevel() {
- /* Test with a supported type */
- String type = AnalysisRequirementFactory.REQUIREMENT_TYPE_2;
- Set<String> values = TmfAnalysisRequirementHelper.getRequirementValues(fTestModuleHelper2, type, ValuePriorityLevel.MANDATORY);
- assertEquals(3, values.size());
-
- /* Test with another value level */
- values = TmfAnalysisRequirementHelper.getRequirementValues(fTestModuleHelper2, type, ValuePriorityLevel.OPTIONAL);
- assertEquals(2, values.size());
-
- /* Test with a type not supported */
- type = AnalysisRequirementFactory.REQUIREMENT_TYPE_1;
- values = TmfAnalysisRequirementHelper.getRequirementValues(fTestModuleHelper2, type, ValuePriorityLevel.MANDATORY);
- assertTrue(values.isEmpty());
- }
-
- /**
- * Test suite for the
- * {@link TmfAnalysisRequirementHelper#getRequirementValuesMap(Iterable)}
- * method
- */
- @Test
- public void testGetRequirementValuesMap() {
- Set<IAnalysisRequirementProvider> providers = new HashSet<>();
- providers.add(fTestModuleHelper2);
- providers.add(fTestModuleHelper);
-
- Multimap<String, String> valuesByType = TmfAnalysisRequirementHelper.getRequirementValuesMap(providers);
- assertFalse(valuesByType.isEmpty());
-
- /* There should be 3 types */
- assertEquals(3, valuesByType.keySet().size());
-
- Collection<String> values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_1);
- assertEquals(4, values.size());
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_1));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_2));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_3));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_5));
-
- values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_2);
- assertEquals(5, values.size());
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_1));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_2));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_3));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_4));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_5));
-
- values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_3);
- assertEquals(3, values.size());
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_3));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_4));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_5));
- }
-
- /**
- * Test suite for the
- * {@link TmfAnalysisRequirementHelper#getRequirementValuesMap(Iterable, ValuePriorityLevel)}
- * method
- */
- @Test
- public void testGetRequirementValuesMapWithLevel() {
- Set<IAnalysisRequirementProvider> providers = new HashSet<>();
- providers.add(fTestModuleHelper2);
- providers.add(fTestModuleHelper);
-
- /* There should be 3 optional requirements types */
- Multimap<String, String> valuesByType = TmfAnalysisRequirementHelper.getRequirementValuesMap(providers, ValuePriorityLevel.OPTIONAL);
- assertTrue(!valuesByType.isEmpty());
- assertEquals(1, valuesByType.keySet().size());
-
- Collection<String> values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_1);
- assertTrue(values.isEmpty());
-
- values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_2);
- assertEquals(2, values.size());
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_2));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_4));
-
- values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_3);
- assertTrue(values.isEmpty());
-
- /* And 3 types with mandatory requirements */
- valuesByType = TmfAnalysisRequirementHelper.getRequirementValuesMap(providers, ValuePriorityLevel.MANDATORY);
- assertTrue(!valuesByType.isEmpty());
- assertEquals(3, valuesByType.keySet().size());
-
- values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_1);
- assertEquals(4, values.size());
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_1));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_2));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_3));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_5));
-
- values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_2);
- assertEquals(3, values.size());
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_1));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_3));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_5));
-
- values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_3);
- assertEquals(3, values.size());
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_3));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_4));
- assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_5));
- }
-
-}
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2014 É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
- *
- * Contributors:
- * Guilliano Molaire - Initial API and implementation
- * Mathieu Rail - Initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.tracecompass.tmf.core.tests.analysis;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-
-import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisRequirement.ValuePriorityLevel;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
-import org.junit.Test;
-
-/**
- * Test suite for the {@link TmfAnalysisRequirement} class.
- *
- * @author Guilliano Molaire
- * @author Mathieu Rail
- */
-public class AnalysisRequirementTest {
-
- /* Requirements used in the tests */
- private TmfAnalysisRequirement fRequirement;
- private TmfAnalysisRequirement fSubRequirement;
-
- /* Types of requirement type strings */
- private static final String TYPE_A = "Test Type A";
- private static final String TYPE_B = "Test Type B";
-
- /* Requirement value name strings */
- private static final String VALUE_A = "Test Value A";
- private static final String VALUE_B = "Test Value B";
- private static final String VALUE_C = "Test Value C";
- private static final String VALUE_D = "Test Value D";
- private static final String VALUE_E = "Test Value E";
- private static final String VALUE_F = "Test Value F";
-
- /* Requirement information strings */
- private static final @NonNull String INFO_A = "This is an information.";
- private static final @NonNull String INFO_B = "This is another information.";
- private static final @NonNull String INFO_C = "This is the last information.";
-
- /**
- * Test suite for the {@link TmfAnalysisRequirement#addInformation} and the
- * {@link TmfAnalysisRequirement#getInformation} methods.
- */
- @Test
- public void testAddAndGetInformation() {
- fRequirement = new TmfAnalysisRequirement(TYPE_A);
-
- fRequirement.addInformation(INFO_A);
- fRequirement.addInformation(INFO_B);
- fRequirement.addInformation(INFO_B);
-
- Set<String> information = fRequirement.getInformation();
-
- assertEquals(2, information.size());
-
- assertTrue(information.contains(INFO_A));
- assertTrue(information.contains(INFO_B));
- }
-
- /**
- * Test suite for the {@link TmfAnalysisRequirement#addValues} and the
- * {@link TmfAnalysisRequirement#addValue} methods.
- */
- @Test
- public void testAddValuesToRequirement() {
- fRequirement = new TmfAnalysisRequirement(TYPE_A);
-
- assertEquals(0, fRequirement.getValues().size());
-
- List<String> values = new ArrayList<>();
- values.add(VALUE_A);
- values.add(VALUE_B);
- values.add(VALUE_C);
- values.add(VALUE_C);
-
- /*
- * Add values to the requirement with the same level, Value C should
- * only exist once
- */
- fRequirement.addValues(values, ValuePriorityLevel.MANDATORY);
- assertEquals(3, fRequirement.getValues().size());
-
- /*
- * The new value should only exist once and its level should be
- * mandatory
- */
- fRequirement.addValue(VALUE_D, ValuePriorityLevel.OPTIONAL);
- fRequirement.addValue(VALUE_D, ValuePriorityLevel.MANDATORY);
-
- assertEquals(4, fRequirement.getValues().size());
- assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_D));
- }
-
- /**
- * Test suite for the {@link TmfAnalysisRequirement#getValueLevel} method.
- */
- @Test
- public void testGetValueLevel() {
- fRequirement = new TmfAnalysisRequirement(TYPE_A);
- fRequirement.addValue(VALUE_A, ValuePriorityLevel.OPTIONAL);
-
- /* Try to get the level of a value */
- assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_A));
-
- /* Try to get the level of a value that doesn't exist */
- assertNull(fRequirement.getValueLevel(VALUE_B));
- }
-
- /**
- * Test suite for the {@link TmfAnalysisRequirement#merge} method with the
- * parameter value MANDATORY.
- */
- @Test
- public void testMergeMandatory() {
- initMergeRequirements(TYPE_A, TYPE_A);
-
- assertTrue(fRequirement.merge(fSubRequirement, ValuePriorityLevel.MANDATORY));
-
- assertEquals(fRequirement.getValues().size(), 6);
-
- assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_A));
- assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_B));
-
- assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_C));
- assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_D));
-
- assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_E));
- assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_F));
-
- Set<String> information = fRequirement.getInformation();
-
- assertEquals(3, information.size());
-
- assertTrue(information.contains(INFO_A));
- assertTrue(information.contains(INFO_B));
- assertTrue(information.contains(INFO_C));
- }
-
- /**
- * Test suite for the {@link TmfAnalysisRequirement#merge} method with the
- * parameter value OPTIONAL.
- */
- @Test
- public void testMergeOptional() {
- initMergeRequirements(TYPE_A, TYPE_A);
-
- assertTrue(fRequirement.merge(fSubRequirement, ValuePriorityLevel.OPTIONAL));
-
- assertEquals(6, fRequirement.getValues().size());
-
- assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_A));
- assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_B));
-
- assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_C));
- assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_D));
-
- assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_E));
- assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_F));
-
- Set<String> information = fRequirement.getInformation();
-
- assertEquals(3, information.size());
-
- assertTrue(information.contains(INFO_A));
- assertTrue(information.contains(INFO_B));
- assertTrue(information.contains(INFO_C));
- }
-
- /**
- * Test suite for the {@link TmfAnalysisRequirement#merge} method with
- * different requirement types.
- */
- @Test
- public void testMergeDifferentTypes() {
- initMergeRequirements(TYPE_A, TYPE_B);
-
- assertFalse(fRequirement.merge(fSubRequirement, ValuePriorityLevel.OPTIONAL));
- }
-
- /**
- * Test suite for the {@link TmfAnalysisRequirement#isSameType} method.
- */
- @Test
- public void testIsSameRequirementType() {
- fRequirement = new TmfAnalysisRequirement(TYPE_A);
-
- assertTrue(fRequirement.isSameType(new TmfAnalysisRequirement(TYPE_A)));
- assertFalse(fRequirement.isSameType(new TmfAnalysisRequirement(TYPE_B)));
- }
-
- /**
- * Initialize the requirement and sub-requirement for the merge tests.
- *
- * @param typeA
- * The type of the first requirement
- * @param typeB
- * The type of the second requirement
- */
- private void initMergeRequirements(String typeA, String typeB) {
- fRequirement = new TmfAnalysisRequirement(typeA);
- fRequirement.addValue(VALUE_A, ValuePriorityLevel.MANDATORY);
- fRequirement.addValue(VALUE_B, ValuePriorityLevel.MANDATORY);
-
- fRequirement.addValue(VALUE_C, ValuePriorityLevel.OPTIONAL);
- fRequirement.addValue(VALUE_D, ValuePriorityLevel.OPTIONAL);
-
- fRequirement.addInformation(INFO_A);
- fRequirement.addInformation(INFO_B);
-
- /* This sub-requirement will be merged into requirement */
- fSubRequirement = new TmfAnalysisRequirement(typeB);
- fSubRequirement.addValue(VALUE_A, ValuePriorityLevel.MANDATORY);
- fSubRequirement.addValue(VALUE_B, ValuePriorityLevel.OPTIONAL);
-
- fSubRequirement.addValue(VALUE_C, ValuePriorityLevel.MANDATORY);
- fSubRequirement.addValue(VALUE_D, ValuePriorityLevel.OPTIONAL);
-
- fSubRequirement.addValue(VALUE_E, ValuePriorityLevel.MANDATORY);
- fSubRequirement.addValue(VALUE_F, ValuePriorityLevel.OPTIONAL);
-
- fSubRequirement.addInformation(INFO_B);
- fSubRequirement.addInformation(INFO_C);
- }
-}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2014 É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
+ *
+ * Contributors:
+ * Guilliano Molaire - Initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.tmf.core.tests.analysis.requirements;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.ValuePriorityLevel;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.IAnalysisRequirementProvider;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirementHelper;
+import org.eclipse.tracecompass.tmf.tests.stubs.analysis.AnalysisModuleTestHelper;
+import org.eclipse.tracecompass.tmf.tests.stubs.analysis.AnalysisModuleTestHelper.moduleStubEnum;
+import org.eclipse.tracecompass.tmf.tests.stubs.analysis.AnalysisRequirementFactory;
+import org.junit.Test;
+
+import com.google.common.collect.Multimap;
+
+/**
+ * Test suite for the {@link TmfAnalysisRequirementHelper} class
+ */
+public class AnalysisRequirementHelperTest {
+
+ private final @NonNull AnalysisModuleTestHelper fTestModuleHelper = new AnalysisModuleTestHelper(moduleStubEnum.TEST);
+ private final @NonNull AnalysisModuleTestHelper fTestModuleHelper2 = new AnalysisModuleTestHelper(moduleStubEnum.TEST2);
+
+ /**
+ * Test suite for the
+ * {@link TmfAnalysisRequirementHelper#getRequirementValues(IAnalysisRequirementProvider, String)}
+ * method
+ */
+ @Test
+ public void testGetRequirementValues() {
+ /* Test with a supported type */
+ String type = AnalysisRequirementFactory.REQUIREMENT_TYPE_1;
+ Set<String> values = TmfAnalysisRequirementHelper.getRequirementValues(fTestModuleHelper, type);
+ assertEquals(AnalysisRequirementFactory.REQUIREMENT_VALUES_1.size(), values.size());
+
+ /* Test with a type not supported */
+ type = AnalysisRequirementFactory.REQUIREMENT_TYPE_2;
+ values = TmfAnalysisRequirementHelper.getRequirementValues(fTestModuleHelper, type);
+ assertTrue(values.isEmpty());
+ }
+
+ /**
+ * Test suite for the
+ * {@link TmfAnalysisRequirementHelper#getRequirementValues(IAnalysisRequirementProvider, String, ValuePriorityLevel)}
+ * method
+ */
+ @Test
+ public void testGetRequirementValuesWithLevel() {
+ /* Test with a supported type */
+ String type = AnalysisRequirementFactory.REQUIREMENT_TYPE_2;
+ Set<String> values = TmfAnalysisRequirementHelper.getRequirementValues(fTestModuleHelper2, type, ValuePriorityLevel.MANDATORY);
+ assertEquals(3, values.size());
+
+ /* Test with another value level */
+ values = TmfAnalysisRequirementHelper.getRequirementValues(fTestModuleHelper2, type, ValuePriorityLevel.OPTIONAL);
+ assertEquals(2, values.size());
+
+ /* Test with a type not supported */
+ type = AnalysisRequirementFactory.REQUIREMENT_TYPE_1;
+ values = TmfAnalysisRequirementHelper.getRequirementValues(fTestModuleHelper2, type, ValuePriorityLevel.MANDATORY);
+ assertTrue(values.isEmpty());
+ }
+
+ /**
+ * Test suite for the
+ * {@link TmfAnalysisRequirementHelper#getRequirementValuesMap(Iterable)}
+ * method
+ */
+ @Test
+ public void testGetRequirementValuesMap() {
+ Set<@NonNull IAnalysisRequirementProvider> providers = new HashSet<>();
+ providers.add(fTestModuleHelper2);
+ providers.add(fTestModuleHelper);
+
+ Multimap<String, String> valuesByType = TmfAnalysisRequirementHelper.getRequirementValuesMap(providers);
+ assertFalse(valuesByType.isEmpty());
+
+ /* There should be 3 types */
+ assertEquals(3, valuesByType.keySet().size());
+
+ Collection<String> values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_1);
+ assertEquals(4, values.size());
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_1));
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_2));
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_3));
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_5));
+
+ values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_2);
+ assertEquals(5, values.size());
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_1));
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_2));
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_3));
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_4));
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_5));
+
+ values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_3);
+ assertEquals(3, values.size());
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_3));
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_4));
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_5));
+ }
+
+ /**
+ * Test suite for the
+ * {@link TmfAnalysisRequirementHelper#getRequirementValuesMap(Iterable, ValuePriorityLevel)}
+ * method
+ */
+ @Test
+ public void testGetRequirementValuesMapWithLevel() {
+ Set<@NonNull IAnalysisRequirementProvider> providers = new HashSet<>();
+ providers.add(fTestModuleHelper2);
+ providers.add(fTestModuleHelper);
+
+ /* There should be 3 optional requirements types */
+ Multimap<String, String> valuesByType = TmfAnalysisRequirementHelper.getRequirementValuesMap(providers, ValuePriorityLevel.OPTIONAL);
+ assertTrue(!valuesByType.isEmpty());
+ assertEquals(1, valuesByType.keySet().size());
+
+ Collection<String> values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_1);
+ assertTrue(values.isEmpty());
+
+ values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_2);
+ assertEquals(2, values.size());
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_2));
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_4));
+
+ values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_3);
+ assertTrue(values.isEmpty());
+
+ /* And 3 types with mandatory requirements */
+ valuesByType = TmfAnalysisRequirementHelper.getRequirementValuesMap(providers, ValuePriorityLevel.MANDATORY);
+ assertTrue(!valuesByType.isEmpty());
+ assertEquals(3, valuesByType.keySet().size());
+
+ values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_1);
+ assertEquals(4, values.size());
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_1));
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_2));
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_3));
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_5));
+
+ values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_2);
+ assertEquals(3, values.size());
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_1));
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_3));
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_5));
+
+ values = valuesByType.get(AnalysisRequirementFactory.REQUIREMENT_TYPE_3);
+ assertEquals(3, values.size());
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_3));
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_4));
+ assertTrue(values.contains(AnalysisRequirementFactory.REQUIREMENT_VALUE_5));
+ }
+
+}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2014 É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
+ *
+ * Contributors:
+ * Guilliano Molaire - Initial API and implementation
+ * Mathieu Rail - Initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.tmf.core.tests.analysis.requirements;
+
+import java.util.ArrayList;
+import java.util.List;
+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.ValuePriorityLevel;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+/**
+ * Test suite for the {@link TmfAnalysisRequirement} class.
+ *
+ * @author Guilliano Molaire
+ * @author Mathieu Rail
+ */
+public class AnalysisRequirementTest {
+
+ /* Requirements used in the tests */
+ private TmfAnalysisRequirement fRequirement;
+ private TmfAnalysisRequirement fSubRequirement;
+
+ /* Types of requirement type strings */
+ private static final @NonNull String TYPE_A = "Test Type A";
+ private static final @NonNull String TYPE_B = "Test Type B";
+
+ /* Requirement value name strings */
+ private static final @NonNull String VALUE_A = "Test Value A";
+ private static final @NonNull String VALUE_B = "Test Value B";
+ private static final @NonNull String VALUE_C = "Test Value C";
+ private static final @NonNull String VALUE_D = "Test Value D";
+ private static final @NonNull String VALUE_E = "Test Value E";
+ private static final @NonNull String VALUE_F = "Test Value F";
+
+ /* Requirement information strings */
+ private static final @NonNull String INFO_A = "This is an information.";
+ private static final @NonNull String INFO_B = "This is another information.";
+ private static final @NonNull String INFO_C = "This is the last information.";
+
+ /**
+ * Test suite for the {@link TmfAnalysisRequirement#addInformation} and the
+ * {@link TmfAnalysisRequirement#getInformation} methods.
+ */
+ @Test
+ public void testAddAndGetInformation() {
+ fRequirement = new TmfAnalysisRequirement(TYPE_A);
+
+ fRequirement.addInformation(INFO_A);
+ fRequirement.addInformation(INFO_B);
+ fRequirement.addInformation(INFO_B);
+
+ Set<String> information = fRequirement.getInformation();
+
+ assertEquals(2, information.size());
+
+ assertTrue(information.contains(INFO_A));
+ assertTrue(information.contains(INFO_B));
+ }
+
+ /**
+ * Test suite for the {@link TmfAnalysisRequirement#addValues} and the
+ * {@link TmfAnalysisRequirement#addValue} methods.
+ */
+ @Test
+ public void testAddValuesToRequirement() {
+ fRequirement = new TmfAnalysisRequirement(TYPE_A);
+
+ assertEquals(0, fRequirement.getValues().size());
+
+ List<@NonNull String> values = new ArrayList<>();
+ values.add(VALUE_A);
+ values.add(VALUE_B);
+ values.add(VALUE_C);
+ values.add(VALUE_C);
+
+ /*
+ * Add values to the requirement with the same level, Value C should
+ * only exist once
+ */
+ fRequirement.addValues(values, ValuePriorityLevel.MANDATORY);
+ assertEquals(3, fRequirement.getValues().size());
+
+ /*
+ * The new value should only exist once and its level should be
+ * mandatory
+ */
+ fRequirement.addValue(VALUE_D, ValuePriorityLevel.OPTIONAL);
+ fRequirement.addValue(VALUE_D, ValuePriorityLevel.MANDATORY);
+
+ assertEquals(4, fRequirement.getValues().size());
+ assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_D));
+ }
+
+ /**
+ * Test suite for the {@link TmfAnalysisRequirement#getValueLevel} method.
+ */
+ @Test
+ public void testGetValueLevel() {
+ fRequirement = new TmfAnalysisRequirement(TYPE_A);
+ fRequirement.addValue(VALUE_A, ValuePriorityLevel.OPTIONAL);
+
+ /* Try to get the level of a value */
+ assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_A));
+
+ /* Try to get the level of a value that doesn't exist */
+ assertNull(fRequirement.getValueLevel(VALUE_B));
+ }
+
+ /**
+ * Test suite for the {@link TmfAnalysisRequirement#merge} method with the
+ * parameter value MANDATORY.
+ */
+ @Test
+ public void testMergeMandatory() {
+ initMergeRequirements(TYPE_A, TYPE_A);
+ TmfAnalysisRequirement subReq = fSubRequirement;
+ assertNotNull(subReq);
+
+ assertTrue(fRequirement.merge(subReq, ValuePriorityLevel.MANDATORY));
+
+ assertEquals(fRequirement.getValues().size(), 6);
+
+ assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_A));
+ assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_B));
+
+ assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_C));
+ assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_D));
+
+ assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_E));
+ assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_F));
+
+ Set<String> information = fRequirement.getInformation();
+
+ assertEquals(3, information.size());
+
+ assertTrue(information.contains(INFO_A));
+ assertTrue(information.contains(INFO_B));
+ assertTrue(information.contains(INFO_C));
+ }
+
+ /**
+ * Test suite for the {@link TmfAnalysisRequirement#merge} method with the
+ * parameter value OPTIONAL.
+ */
+ @Test
+ public void testMergeOptional() {
+ initMergeRequirements(TYPE_A, TYPE_A);
+ TmfAnalysisRequirement subReq = fSubRequirement;
+ assertNotNull(subReq);
+
+ assertTrue(fRequirement.merge(subReq, ValuePriorityLevel.OPTIONAL));
+
+ assertEquals(6, fRequirement.getValues().size());
+
+ assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_A));
+ assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_B));
+
+ assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_C));
+ assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_D));
+
+ assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_E));
+ assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_F));
+
+ Set<String> information = fRequirement.getInformation();
+
+ assertEquals(3, information.size());
+
+ assertTrue(information.contains(INFO_A));
+ assertTrue(information.contains(INFO_B));
+ assertTrue(information.contains(INFO_C));
+ }
+
+ /**
+ * Test suite for the {@link TmfAnalysisRequirement#merge} method with
+ * different requirement types.
+ */
+ @Test
+ public void testMergeDifferentTypes() {
+ initMergeRequirements(TYPE_A, TYPE_B);
+ TmfAnalysisRequirement subReq = fSubRequirement;
+ assertNotNull(subReq);
+
+ assertFalse(fRequirement.merge(subReq, ValuePriorityLevel.OPTIONAL));
+ }
+
+ /**
+ * Test suite for the {@link TmfAnalysisRequirement#isSameType} method.
+ */
+ @Test
+ public void testIsSameRequirementType() {
+ fRequirement = new TmfAnalysisRequirement(TYPE_A);
+
+ assertTrue(fRequirement.isSameType(new TmfAnalysisRequirement(TYPE_A)));
+ assertFalse(fRequirement.isSameType(new TmfAnalysisRequirement(TYPE_B)));
+ }
+
+ /**
+ * Initialize the requirement and sub-requirement for the merge tests.
+ *
+ * @param typeA
+ * The type of the first requirement
+ * @param typeB
+ * The type of the second requirement
+ */
+ private void initMergeRequirements(@NonNull String typeA, @NonNull String typeB) {
+ fRequirement = new TmfAnalysisRequirement(typeA);
+ fRequirement.addValue(VALUE_A, ValuePriorityLevel.MANDATORY);
+ fRequirement.addValue(VALUE_B, ValuePriorityLevel.MANDATORY);
+
+ fRequirement.addValue(VALUE_C, ValuePriorityLevel.OPTIONAL);
+ fRequirement.addValue(VALUE_D, ValuePriorityLevel.OPTIONAL);
+
+ fRequirement.addInformation(INFO_A);
+ fRequirement.addInformation(INFO_B);
+
+ /* This sub-requirement will be merged into requirement */
+ fSubRequirement = new TmfAnalysisRequirement(typeB);
+ fSubRequirement.addValue(VALUE_A, ValuePriorityLevel.MANDATORY);
+ fSubRequirement.addValue(VALUE_B, ValuePriorityLevel.OPTIONAL);
+
+ fSubRequirement.addValue(VALUE_C, ValuePriorityLevel.MANDATORY);
+ fSubRequirement.addValue(VALUE_D, ValuePriorityLevel.OPTIONAL);
+
+ fSubRequirement.addValue(VALUE_E, ValuePriorityLevel.MANDATORY);
+ fSubRequirement.addValue(VALUE_F, ValuePriorityLevel.OPTIONAL);
+
+ fSubRequirement.addInformation(INFO_B);
+ fSubRequirement.addInformation(INFO_C);
+ }
+}
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.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
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;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisRequirement.ValuePriorityLevel;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.ValuePriorityLevel;
import com.google.common.collect.ImmutableSet;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.tracecompass.tmf.core.analysis.TmfAbstractAnalysisModule;
-import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisRequirement;
-import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisRequirement.ValuePriorityLevel;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.ValuePriorityLevel;
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;
org.eclipse.tracecompass.internal.tmf.core.trace.indexer;x-friends:="org.eclipse.tracecompass.tmf.core.tests",
org.eclipse.tracecompass.tmf.core,
org.eclipse.tracecompass.tmf.core.analysis,
+ org.eclipse.tracecompass.tmf.core.analysis.requirements,
org.eclipse.tracecompass.tmf.core.callstack,
org.eclipse.tracecompass.tmf.core.component,
org.eclipse.tracecompass.tmf.core.event,
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.IAnalysisRequirementProvider;
import org.eclipse.tracecompass.tmf.core.component.ITmfComponent;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.IAnalysisRequirementProvider;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.osgi.framework.Bundle;
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2014 É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
- *
- * Contributors:
- * Guilliano Molaire - Initial API and implementation
- * Mathieu Rail - Initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.tracecompass.tmf.core.analysis;
-
-import org.eclipse.jdt.annotation.NonNullByDefault;
-
-/**
- * Interface that provides the necessary methods for an analysis to define its
- * requirements.
- *
- * @author Guilliano Molaire
- * @author Mathieu Rail
- */
-@NonNullByDefault
-public interface IAnalysisRequirementProvider {
-
- /**
- * Gets the requirements associated with this analysis.
- *
- * @return List of requirement
- */
- Iterable<TmfAnalysisRequirement> getAnalysisRequirements();
-}
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.TmfAnalysisRequirement.ValuePriorityLevel;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement;
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.ValuePriorityLevel;
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;
}
@Override
- public Iterable<TmfAnalysisRequirement> getAnalysisRequirements() {
+ public Iterable<@NonNull TmfAnalysisRequirement> getAnalysisRequirements() {
return Collections.EMPTY_SET;
}
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.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.project.model.TmfTraceType;
import org.eclipse.tracecompass.tmf.core.project.model.TraceTypeHelper;
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2014 É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
- *
- * Contributors:
- * Mathieu Rail - Initial API and implementation
- * Guilliano Molaire - Initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.tracecompass.tmf.core.analysis;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-
-import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
-import org.eclipse.tracecompass.tmf.core.trace.ITmfTraceWithPreDefinedEvents;
-import org.eclipse.tracecompass.tmf.core.trace.TmfEventTypeCollectionHelper;
-
-/**
- * Class that contains all the values associated with a type needed by an
- * analysis in order to execute. Each value is peered with a level that
- * determines the importance of that specific value for the requirement.
- *
- * The type gives an indication about the kind of value the requirement
- * contains. The value should depend on the type. For instance, a requirement
- * type could be "event" and all the values that would be added in the
- * requirement object could indicate the possible events handled by the
- * analysis.
- *
- * For these values, a level will be assigned indicating how important the value
- * is based on two possibilities: Mandatory or optional.
- *
- * 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
- */
-public class TmfAnalysisRequirement {
-
- /**
- * String for requirement type 'event', that can be used by analysis
- */
- public static final String TYPE_EVENT = "event"; //$NON-NLS-1$
-
- private final String fType;
- private final Map<String, ValuePriorityLevel> fValues = new HashMap<>();
- private final Set<@NonNull String> fInformation = new HashSet<>();
-
- /**
- * The possible level for each value. They must be listed in ascending order
- * of priority.
- */
- public enum ValuePriorityLevel {
- /** The value could be absent and the analysis would still work */
- OPTIONAL,
- /** The value must be present at runtime (for the analysis) */
- MANDATORY
- }
-
- /**
- * Constructor
- *
- * @param type
- * The type of the requirement
- */
- public TmfAnalysisRequirement(String type) {
- fType = type;
- }
-
- /**
- * Constructor. Instantiate a requirement object with a list of values of
- * the same level
- *
- * @param type
- * The type of the requirement
- * @param values
- * All the values associated with that type
- * @param level
- * A level associated with all the values
- */
- public TmfAnalysisRequirement(String type, Iterable<String> values, ValuePriorityLevel level) {
- fType = type;
- addValues(values, level);
- }
-
- /**
- * Merges the values of the specified requirement with those of this
- * requirement. All new values will retain their priority value level. If a
- * value was already inside the current requirement, the current priority
- * level will be overridden if the new priority level is higher.
- *
- * @param subRequirement
- * The requirement to be merged into the current one
- * @param maxSubRequirementValueLevel
- * The level associated with all the new values or currently
- * lower priority ones
- * @return True if the merge was successful
- */
- public Boolean merge(TmfAnalysisRequirement subRequirement, ValuePriorityLevel maxSubRequirementValueLevel) {
- /* Two requirements can't be merged if their types are different */
- if (!isSameType(subRequirement)) {
- return false;
- }
-
- Set<String> values = subRequirement.getValues();
- for (String value : values) {
- /*
- * Sub-requirement value levels are limited to
- * maxSubRequirementValueLevel, so the level associated with the
- * values in the merge is the minimum value between
- * maxSubRequirementValueLevel and its true level.
- */
- int minLevel = Math.min(subRequirement.getValueLevel(value).ordinal(), maxSubRequirementValueLevel.ordinal());
- ValuePriorityLevel subRequirementValueLevel = ValuePriorityLevel.values()[minLevel];
-
- if (fValues.containsKey(value)) {
- /*
- * If a value is already in a requirement, we update the level
- * by the highest value between the current level in the
- * requirement and the level of the value in the
- * sub-requirement.
- */
- ValuePriorityLevel requirementValueLevel = getValueLevel(value);
-
- int newValueLevel = Math.max(requirementValueLevel.ordinal(), subRequirementValueLevel.ordinal());
- ValuePriorityLevel highestLevel = ValuePriorityLevel.values()[newValueLevel];
- addValue(value, highestLevel);
- }
- else {
- addValue(value, subRequirementValueLevel);
- }
- }
-
- /* Merge the information */
- fInformation.addAll(subRequirement.getInformation());
-
- return true;
- }
-
- /**
- * Adds a list of value inside the requirement with the same level.
- *
- * @param values
- * A list of value
- * @param level
- * The level associated with all the values
- */
- public void addValues(Iterable<String> values, ValuePriorityLevel level) {
- for (String value : values) {
- addValue(value, level);
- }
- }
-
- /**
- * Adds a value with his associated level into the requirement. If the value
- * is already contained in the requirement the method modifies its existing
- * value level.
- *
- * @param value
- * The value
- * @param level
- * The level
- */
- public void addValue(String value, ValuePriorityLevel level) {
- synchronized (fValues) {
- fValues.put(value, level);
- }
- }
-
- /**
- * Adds an information about the requirement.
- *
- * @param information
- * The information to be added
- */
- public void addInformation(@NonNull String information) {
- fInformation.add(information);
- }
-
- /**
- * Determines if the analysis requirement has the same type of another
- * requirement.
- *
- * @param requirement
- * Requirement whose type is to be compared to this requirement's
- * type.
- * @return True if the two requirements have the same type; otherwise false
- */
- public Boolean isSameType(TmfAnalysisRequirement requirement) {
- return fType.equals(requirement.getType());
- }
-
- /**
- * Gets the requirement type. The type is read only.
- *
- * @return The type of this requirement
- */
- public String getType() {
- return fType;
- }
-
- /**
- * Gets all the values associated with the requirement.
- *
- * @return Set containing the values
- */
- public Set<String> getValues() {
- synchronized (fValues) {
- return fValues.keySet();
- }
- }
-
- /**
- * Gets all the values associated with the requirement with a given priority
- * level.
- *
- * @param level
- * The desired level
- * @return Set containing the values with the given priority level
- */
- public Set<String> getValues(ValuePriorityLevel level) {
- synchronized (fValues) {
- Set<String> values = new HashSet<>();
- for (Entry<String, ValuePriorityLevel> entry : fValues.entrySet()) {
- if (entry.getValue() == level) {
- values.add(entry.getKey());
- }
- }
- return values;
- }
- }
-
- /**
- * Gets information about the requirement.
- *
- * @return The set of all the information
- */
- public Set<@NonNull String> getInformation() {
- return fInformation;
- }
-
- /**
- * Gets the level associated with a particular type
- *
- * @param value
- * The value
- * @return The level or null if the value does not exist
- */
- public ValuePriorityLevel getValueLevel(String value) {
- synchronized (fValues) {
- return fValues.get(value);
- }
- }
-
- /**
- * 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
- */
- public boolean isFulfilled(@NonNull ITmfTrace trace) {
- switch (fType) {
- case TYPE_EVENT:
- if (trace instanceof ITmfTraceWithPreDefinedEvents) {
- Set<String> traceEvents = TmfEventTypeCollectionHelper.getEventNames(((ITmfTraceWithPreDefinedEvents) trace).getContainedEventTypes());
- Set<String> mandatoryValues = getValues(ValuePriorityLevel.MANDATORY);
- return traceEvents.containsAll(mandatoryValues);
- }
- break;
- default:
- return true;
- }
- return true;
- }
-
- @Override
- public String toString() {
- return fType + ": " + fValues; //$NON-NLS-1$
- }
-}
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2014 É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
- *
- * Contributors:
- * Guilliano Molaire - Initial API and implementation
- * Mathieu Rail - Initial API and implementation
- *******************************************************************************/
-
-package org.eclipse.tracecompass.tmf.core.analysis;
-
-import java.util.HashSet;
-import java.util.Set;
-
-import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisRequirement.ValuePriorityLevel;
-
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.SetMultimap;
-
-/**
- * Helper class to simplify analysis requirement management.
- *
- * @author Guilliano Molaire
- */
-public final class TmfAnalysisRequirementHelper {
-
- /**
- * Private constructor. The class should not be instantiated.
- */
- private TmfAnalysisRequirementHelper() {
- }
-
- /**
- * Gets the requirement values of a given type from an analysis requirement
- * provider. Only values linked to the type will be returned.
- *
- * @param provider
- * The analysis requirement provider
- * @param type
- * The type of the requirement values we need
- * @return The list of values for the specified type
- */
- public static Set<String> getRequirementValues(IAnalysisRequirementProvider provider, String type) {
- Set<String> values = new HashSet<>();
- for (TmfAnalysisRequirement requirement : provider.getAnalysisRequirements()) {
- if (requirement.getType().equalsIgnoreCase(type)) {
- values.addAll(requirement.getValues());
- }
- }
- return values;
- }
-
- /**
- * Gets the requirement values of a given type from an analysis requirement
- * provider, with the specified level. Only values associated with that type
- * and level will be returned.
- *
- * @param provider
- * The analysis requirement provider
- * @param type
- * The type of the requirement values we need
- * @param level
- * The priority level of the values to be returned
- * @return The list of values for the specified type
- */
- public static Set<String> getRequirementValues(IAnalysisRequirementProvider provider, String type, ValuePriorityLevel level) {
- Set<String> values = new HashSet<>();
- for (TmfAnalysisRequirement requirement : provider.getAnalysisRequirements()) {
- if (requirement.getType().equalsIgnoreCase(type)) {
- for (String value : requirement.getValues()) {
- if (requirement.getValueLevel(value) == level) {
- values.add(value);
- }
- }
- }
- }
- return values;
- }
-
- /**
- * Gets a map in which the keys are the types of different requirements and
- * the values represent a set of requirement values linked to that type.
- *
- * @param providers
- * The set of analysis requirement provider
- * @return A map with the values keyed by type
- */
- public static SetMultimap<String, String> getRequirementValuesMap(Iterable<IAnalysisRequirementProvider> providers) {
- SetMultimap<String, String> valuesByType = HashMultimap.create();
- for (IAnalysisRequirementProvider provider : providers) {
- for (TmfAnalysisRequirement requirement : provider.getAnalysisRequirements()) {
- valuesByType.putAll(requirement.getType(), requirement.getValues());
- }
- }
- return valuesByType;
- }
-
- /**
- * Gets a map in which the keys are the types of different requirements and
- * the values represents a list of requirement values linked to that type.
- * We only take values with the same priority level as the argument.
- *
- * @param providers
- * The set of analysis requirement provider
- * @param level
- * The priority level of the values to be returned
- * @return A map with the values keyed by type
- */
- public static SetMultimap<String, String> getRequirementValuesMap(Iterable<IAnalysisRequirementProvider> providers, ValuePriorityLevel level) {
- SetMultimap<String, String> valuesByType = HashMultimap.create();
- for (IAnalysisRequirementProvider provider : providers) {
- for (TmfAnalysisRequirement requirement : provider.getAnalysisRequirements()) {
- /* Since it's a set, there will be no duplicate */
- for (String value : requirement.getValues()) {
- if (requirement.getValueLevel(value) == level) {
- valuesByType.put(requirement.getType(), value);
- }
- }
- }
- }
- return valuesByType;
- }
-}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2014 É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
+ *
+ * Contributors:
+ * Guilliano Molaire - Initial API and implementation
+ * Mathieu Rail - Initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.tmf.core.analysis.requirements;
+
+/**
+ * Interface that provides the necessary methods for an analysis to define its
+ * requirements.
+ *
+ * @author Guilliano Molaire
+ * @author Mathieu Rail
+ * @since 2.0
+ */
+public interface IAnalysisRequirementProvider {
+
+ /**
+ * Gets the requirements associated with this analysis.
+ *
+ * @return List of requirement
+ */
+ Iterable<TmfAnalysisRequirement> getAnalysisRequirements();
+}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2014 É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
+ *
+ * Contributors:
+ * Mathieu Rail - Initial API and implementation
+ * Guilliano Molaire - Initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.tmf.core.analysis.requirements;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
+import org.eclipse.tracecompass.tmf.core.trace.ITmfTraceWithPreDefinedEvents;
+import org.eclipse.tracecompass.tmf.core.trace.TmfEventTypeCollectionHelper;
+
+/**
+ * Class that contains all the values associated with a type needed by an
+ * analysis in order to execute. Each value is peered with a level that
+ * determines the importance of that specific value for the requirement.
+ *
+ * The type gives an indication about the kind of value the requirement
+ * contains. The value should depend on the type. For instance, a requirement
+ * type could be "event" and all the values that would be added in the
+ * requirement object could indicate the possible events handled by the
+ * analysis.
+ *
+ * For these values, a level will be assigned indicating how important the value
+ * is based on two possibilities: Mandatory or optional.
+ *
+ * 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
+ * @since 2.0
+ */
+public class TmfAnalysisRequirement {
+
+ /**
+ * String for requirement type 'event', that can be used by analysis
+ */
+ public static final String TYPE_EVENT = "event"; //$NON-NLS-1$
+
+ private final String fType;
+ private final Map<String, @NonNull ValuePriorityLevel> fValues = new HashMap<>();
+ private final Set<@NonNull String> fInformation = new HashSet<>();
+
+ /**
+ * The possible level for each value. They must be listed in ascending order
+ * of priority.
+ */
+ public enum ValuePriorityLevel {
+ /** The value could be absent and the analysis would still work */
+ OPTIONAL,
+ /** The value must be present at runtime (for the analysis) */
+ MANDATORY
+ }
+
+ /**
+ * Constructor
+ *
+ * @param type
+ * The type of the requirement
+ */
+ public TmfAnalysisRequirement(String type) {
+ fType = type;
+ }
+
+ /**
+ * Constructor. Instantiate a requirement object with a list of values of
+ * the same level
+ *
+ * @param type
+ * The type of the requirement
+ * @param values
+ * All the values associated with that type
+ * @param level
+ * A level associated with all the values
+ */
+ public TmfAnalysisRequirement(String type, Iterable<String> values, ValuePriorityLevel level) {
+ fType = type;
+ addValues(values, level);
+ }
+
+ /**
+ * Merges the values of the specified requirement with those of this
+ * requirement. All new values will retain their priority value level. If a
+ * value was already inside the current requirement, the current priority
+ * level will be overridden if the new priority level is higher.
+ *
+ * @param subRequirement
+ * The requirement to be merged into the current one
+ * @param maxSubRequirementValueLevel
+ * The level associated with all the new values or currently
+ * lower priority ones
+ * @return True if the merge was successful
+ */
+ public Boolean merge(TmfAnalysisRequirement subRequirement, ValuePriorityLevel maxSubRequirementValueLevel) {
+ /* Two requirements can't be merged if their types are different */
+ if (!isSameType(subRequirement)) {
+ return false;
+ }
+
+ Set<String> values = subRequirement.getValues();
+ for (String value : values) {
+ /*
+ * Sub-requirement value levels are limited to
+ * maxSubRequirementValueLevel, so the level associated with the
+ * values in the merge is the minimum value between
+ * maxSubRequirementValueLevel and its true level.
+ */
+ ValuePriorityLevel valueLevel = subRequirement.getValueLevel(value);
+ if (valueLevel == null) {
+ throw new NullPointerException();
+ }
+ int minLevel = Math.min(valueLevel.ordinal(), maxSubRequirementValueLevel.ordinal());
+ ValuePriorityLevel subRequirementValueLevel = ValuePriorityLevel.values()[minLevel];
+
+ if (fValues.containsKey(value)) {
+ /*
+ * If a value is already in a requirement, we update the level
+ * by the highest value between the current level in the
+ * requirement and the level of the value in the
+ * sub-requirement.
+ */
+ ValuePriorityLevel requirementValueLevel = getValueLevel(value);
+ if (requirementValueLevel == null) {
+ throw new NullPointerException();
+ }
+
+ int newValueLevel = Math.max(requirementValueLevel.ordinal(), subRequirementValueLevel.ordinal());
+ ValuePriorityLevel highestLevel = ValuePriorityLevel.values()[newValueLevel];
+ addValue(value, highestLevel);
+ }
+ else {
+ addValue(value, subRequirementValueLevel);
+ }
+ }
+
+ /* Merge the information */
+ fInformation.addAll(subRequirement.getInformation());
+
+ return true;
+ }
+
+ /**
+ * Adds a list of value inside the requirement with the same level.
+ *
+ * @param values
+ * A list of value
+ * @param level
+ * The level associated with all the values
+ */
+ public void addValues(Iterable<String> values, ValuePriorityLevel level) {
+ for (String value : values) {
+ addValue(value, level);
+ }
+ }
+
+ /**
+ * Adds a value with his associated level into the requirement. If the value
+ * is already contained in the requirement the method modifies its existing
+ * value level.
+ *
+ * @param value
+ * The value
+ * @param level
+ * The level
+ */
+ public void addValue(String value, ValuePriorityLevel level) {
+ synchronized (fValues) {
+ fValues.put(value, level);
+ }
+ }
+
+ /**
+ * Adds an information about the requirement.
+ *
+ * @param information
+ * The information to be added
+ */
+ public void addInformation(String information) {
+ fInformation.add(information);
+ }
+
+ /**
+ * Determines if the analysis requirement has the same type of another
+ * requirement.
+ *
+ * @param requirement
+ * Requirement whose type is to be compared to this requirement's
+ * type.
+ * @return True if the two requirements have the same type; otherwise false
+ */
+ public Boolean isSameType(TmfAnalysisRequirement requirement) {
+ return fType.equals(requirement.getType());
+ }
+
+ /**
+ * Gets the requirement type. The type is read only.
+ *
+ * @return The type of this requirement
+ */
+ public String getType() {
+ return fType;
+ }
+
+ /**
+ * Gets all the values associated with the requirement.
+ *
+ * @return Set containing the values
+ */
+ public Set<String> getValues() {
+ synchronized (fValues) {
+ return fValues.keySet();
+ }
+ }
+
+ /**
+ * Gets all the values associated with the requirement with a given priority
+ * level.
+ *
+ * @param level
+ * The desired level
+ * @return Set containing the values with the given priority level
+ */
+ public Set<String> getValues(ValuePriorityLevel level) {
+ synchronized (fValues) {
+ Set<String> values = new HashSet<>();
+ for (Entry<String, ValuePriorityLevel> entry : fValues.entrySet()) {
+ if (entry.getValue() == level) {
+ values.add(entry.getKey());
+ }
+ }
+ return values;
+ }
+ }
+
+ /**
+ * Gets information about the requirement.
+ *
+ * @return The set of all the information
+ */
+ public Set<@NonNull String> getInformation() {
+ return fInformation;
+ }
+
+ /**
+ * Gets the level associated with a particular type
+ *
+ * @param value
+ * The value
+ * @return The level or null if the value does not exist
+ */
+ public @Nullable ValuePriorityLevel getValueLevel(String value) {
+ synchronized (fValues) {
+ return fValues.get(value);
+ }
+ }
+
+ /**
+ * 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
+ */
+ public boolean isFulfilled(ITmfTrace trace) {
+ switch (fType) {
+ case TYPE_EVENT:
+ if (trace instanceof ITmfTraceWithPreDefinedEvents) {
+ Set<String> traceEvents = TmfEventTypeCollectionHelper.getEventNames(((ITmfTraceWithPreDefinedEvents) trace).getContainedEventTypes());
+ Set<String> mandatoryValues = getValues(ValuePriorityLevel.MANDATORY);
+ return traceEvents.containsAll(mandatoryValues);
+ }
+ break;
+ default:
+ return true;
+ }
+ return true;
+ }
+
+ @Override
+ public String toString() {
+ return fType + ": " + fValues; //$NON-NLS-1$
+ }
+}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2014 É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
+ *
+ * Contributors:
+ * Guilliano Molaire - Initial API and implementation
+ * Mathieu Rail - Initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.tmf.core.analysis.requirements;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.eclipse.tracecompass.tmf.core.analysis.requirements.TmfAnalysisRequirement.ValuePriorityLevel;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.SetMultimap;
+
+/**
+ * Helper class to simplify analysis requirement management.
+ *
+ * @author Guilliano Molaire
+ * @since 2.0
+ */
+public final class TmfAnalysisRequirementHelper {
+
+ /**
+ * Private constructor. The class should not be instantiated.
+ */
+ private TmfAnalysisRequirementHelper() {
+ }
+
+ /**
+ * Gets the requirement values of a given type from an analysis requirement
+ * provider. Only values linked to the type will be returned.
+ *
+ * @param provider
+ * The analysis requirement provider
+ * @param type
+ * The type of the requirement values we need
+ * @return The list of values for the specified type
+ */
+ public static Set<String> getRequirementValues(IAnalysisRequirementProvider provider, String type) {
+ Set<String> values = new HashSet<>();
+ for (TmfAnalysisRequirement requirement : provider.getAnalysisRequirements()) {
+ if (requirement.getType().equalsIgnoreCase(type)) {
+ values.addAll(requirement.getValues());
+ }
+ }
+ return values;
+ }
+
+ /**
+ * Gets the requirement values of a given type from an analysis requirement
+ * provider, with the specified level. Only values associated with that type
+ * and level will be returned.
+ *
+ * @param provider
+ * The analysis requirement provider
+ * @param type
+ * The type of the requirement values we need
+ * @param level
+ * The priority level of the values to be returned
+ * @return The list of values for the specified type
+ */
+ public static Set<String> getRequirementValues(IAnalysisRequirementProvider provider, String type, ValuePriorityLevel level) {
+ Set<String> values = new HashSet<>();
+ for (TmfAnalysisRequirement requirement : provider.getAnalysisRequirements()) {
+ if (requirement.getType().equalsIgnoreCase(type)) {
+ for (String value : requirement.getValues()) {
+ if (requirement.getValueLevel(value) == level) {
+ values.add(value);
+ }
+ }
+ }
+ }
+ return values;
+ }
+
+ /**
+ * Gets a map in which the keys are the types of different requirements and
+ * the values represent a set of requirement values linked to that type.
+ *
+ * @param providers
+ * The set of analysis requirement provider
+ * @return A map with the values keyed by type
+ */
+ public static SetMultimap<String, String> getRequirementValuesMap(Iterable<IAnalysisRequirementProvider> providers) {
+ SetMultimap<String, String> valuesByType = HashMultimap.create();
+ for (IAnalysisRequirementProvider provider : providers) {
+ for (TmfAnalysisRequirement requirement : provider.getAnalysisRequirements()) {
+ valuesByType.putAll(requirement.getType(), requirement.getValues());
+ }
+ }
+ return valuesByType;
+ }
+
+ /**
+ * Gets a map in which the keys are the types of different requirements and
+ * the values represents a list of requirement values linked to that type.
+ * We only take values with the same priority level as the argument.
+ *
+ * @param providers
+ * The set of analysis requirement provider
+ * @param level
+ * The priority level of the values to be returned
+ * @return A map with the values keyed by type
+ */
+ public static SetMultimap<String, String> getRequirementValuesMap(Iterable<IAnalysisRequirementProvider> providers, ValuePriorityLevel level) {
+ SetMultimap<String, String> valuesByType = HashMultimap.create();
+ for (IAnalysisRequirementProvider provider : providers) {
+ for (TmfAnalysisRequirement requirement : provider.getAnalysisRequirements()) {
+ /* Since it's a set, there will be no duplicate */
+ for (String value : requirement.getValues()) {
+ if (requirement.getValueLevel(value) == level) {
+ valuesByType.put(requirement.getType(), value);
+ }
+ }
+ }
+ }
+ return valuesByType;
+ }
+}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 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
+ *******************************************************************************/
+
+@org.eclipse.jdt.annotation.NonNullByDefault
+package org.eclipse.tracecompass.tmf.core.analysis.requirements;
projects / deliverable / tracecompass.git / commitdiff
