From: Alexandre Montplaisir Date: Mon, 30 Sep 2013 18:38:26 +0000 (-0400) Subject: tmf: TmfStateSystemOperations tweaks X-Git-Url: http://git.efficios.com/?a=commitdiff_plain;h=64d156777bc4aaac47dc7d583c44d39b88d55c83;p=deliverable%2Ftracecompass.git tmf: TmfStateSystemOperations tweaks Some tweaks to the new State System Operations class: - Made it a full static class, with static methods only. - Throw relevant exceptions back to the user (blame where blame is due!) - Handle other exceptions accordingly. - Use switch/case blocks, so we get warnings here if we ever add new state value types. Change-Id: Ifd409b8a4f38c5b0d1b64afc1985b0717973d549 Signed-off-by: Alexandre Montplaisir Reviewed-on: https://git.eclipse.org/r/16895 Tested-by: Hudson CI Reviewed-by: Patrick Tasse IP-Clean: Patrick Tasse --- diff --git a/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderTest.java b/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderTest.java index be42a9596e..ecd53fc975 100644 --- a/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderTest.java +++ b/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderTest.java @@ -50,7 +50,6 @@ public class TmfMipmapStateProviderTest { private static final double DELTA = 0.0001; private static final long TEST_TIMESTAMP = 12345000L; private static StateSystem ssq; - private static TmfStateSystemOperations sso; /** * Startup code, build a state system with n attributes always going up @@ -61,7 +60,6 @@ public class TmfMipmapStateProviderTest { TmfMipmapStateProviderStub mmp = new TmfMipmapStateProviderStub(RESOLUTION, Type.LONG); IStateHistoryBackend be = new InMemoryBackend(0); ssq = new StateSystem(be); - sso = new TmfStateSystemOperations(ssq); mmp.assignTargetStateSystem(ssq); for (long time = START_TIME; time <= END_TIME; time += INTERVAL) { @@ -427,28 +425,30 @@ public class TmfMipmapStateProviderTest { long max; int quark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); - max = sso.queryRangeMax(0, START_TIME, quark).unboxLong(); + max = TmfStateSystemOperations.queryRangeMax(ssq, 0, START_TIME, quark).unboxLong(); assertEquals(START_TIME / INTERVAL, max); - max = sso.queryRangeMax(START_TIME, START_TIME, quark).unboxLong(); + max = TmfStateSystemOperations.queryRangeMax(ssq, START_TIME, START_TIME, quark).unboxLong(); assertEquals(START_TIME / INTERVAL, max); - max = sso.queryRangeMax(START_TIME, END_TIME / 2, quark).unboxLong(); + max = TmfStateSystemOperations.queryRangeMax(ssq, START_TIME, END_TIME / 2, quark).unboxLong(); assertEquals((END_TIME / 2 / INTERVAL), max); - max = sso.queryRangeMax(0, END_TIME, quark).unboxLong(); + max = TmfStateSystemOperations.queryRangeMax(ssq, 0, END_TIME, quark).unboxLong(); assertEquals(END_TIME / INTERVAL, max); - max = sso.queryRangeMax(END_TIME / 2, END_TIME, quark).unboxLong(); + max = TmfStateSystemOperations.queryRangeMax(ssq, END_TIME / 2, END_TIME, quark).unboxLong(); assertEquals(END_TIME / INTERVAL, max); - max = sso.queryRangeMax(START_TIME - INTERVAL / 2, END_TIME / 2 + INTERVAL / 2, quark).unboxLong(); + max = TmfStateSystemOperations.queryRangeMax(ssq, START_TIME - INTERVAL / 2, END_TIME / 2 + INTERVAL / 2, quark).unboxLong(); assertEquals(END_TIME / 2 / INTERVAL, max); } catch (AttributeNotFoundException e) { fail(e.getMessage()); } catch (StateValueTypeException e) { fail(e.getMessage()); + } catch (TimeRangeException e) { + fail(e.getMessage()); } } @@ -467,28 +467,30 @@ public class TmfMipmapStateProviderTest { long min; int quark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); - min = sso.queryRangeMin(0, START_TIME, quark).unboxLong(); + min = TmfStateSystemOperations.queryRangeMin(ssq, 0, START_TIME, quark).unboxLong(); assertEquals(START_TIME / INTERVAL, min); - min = sso.queryRangeMin(START_TIME, START_TIME, quark).unboxLong(); + min = TmfStateSystemOperations.queryRangeMin(ssq, START_TIME, START_TIME, quark).unboxLong(); assertEquals(START_TIME / INTERVAL, min); - min = sso.queryRangeMin(START_TIME, END_TIME / 2, quark).unboxLong(); + min = TmfStateSystemOperations.queryRangeMin(ssq, START_TIME, END_TIME / 2, quark).unboxLong(); assertEquals((START_TIME / INTERVAL), min); - min = sso.queryRangeMin(0, END_TIME, quark).unboxLong(); + min = TmfStateSystemOperations.queryRangeMin(ssq, 0, END_TIME, quark).unboxLong(); assertEquals(START_TIME / INTERVAL, min); - min = sso.queryRangeMin(END_TIME / 2, END_TIME, quark).unboxLong(); + min = TmfStateSystemOperations.queryRangeMin(ssq, END_TIME / 2, END_TIME, quark).unboxLong(); assertEquals(END_TIME / 2 / INTERVAL, min); - min = sso.queryRangeMin(START_TIME - INTERVAL / 2, END_TIME / 2 + INTERVAL / 2, quark).unboxLong(); + min = TmfStateSystemOperations.queryRangeMin(ssq, START_TIME - INTERVAL / 2, END_TIME / 2 + INTERVAL / 2, quark).unboxLong(); assertEquals(START_TIME / INTERVAL, min); } catch (AttributeNotFoundException e) { fail(e.getMessage()); } catch (StateValueTypeException e) { fail(e.getMessage()); + } catch (TimeRangeException e) { + fail(e.getMessage()); } } @@ -506,26 +508,30 @@ public class TmfMipmapStateProviderTest { double avg; int quark = ssq.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); - avg = sso.queryRangeAverage(0, START_TIME, quark); + avg = TmfStateSystemOperations.queryRangeAverage(ssq, 0, START_TIME, quark); assertEquals((double) (START_TIME - INTERVAL) / INTERVAL, avg, DELTA); - avg = sso.queryRangeAverage(START_TIME, START_TIME, quark); + avg = TmfStateSystemOperations.queryRangeAverage(ssq, START_TIME, START_TIME, quark); assertEquals((double) START_TIME / INTERVAL, avg, DELTA); - avg = sso.queryRangeAverage(START_TIME, END_TIME / 2, quark); + avg = TmfStateSystemOperations.queryRangeAverage(ssq, START_TIME, END_TIME / 2, quark); assertEquals((double) (START_TIME + (END_TIME / 2 - INTERVAL)) / 2 / INTERVAL, avg, DELTA); - avg = sso.queryRangeAverage(0, END_TIME, quark); + avg = TmfStateSystemOperations.queryRangeAverage(ssq, 0, END_TIME, quark); assertEquals((double) (END_TIME - INTERVAL) / 2 / INTERVAL, avg, DELTA); - avg = sso.queryRangeAverage(END_TIME / 2, END_TIME, quark); + avg = TmfStateSystemOperations.queryRangeAverage(ssq, END_TIME / 2, END_TIME, quark); assertEquals((double) (END_TIME / 2 + (END_TIME - INTERVAL)) / 2 / INTERVAL, avg, DELTA); - avg = sso.queryRangeAverage(START_TIME - INTERVAL / 2, END_TIME / 2 + INTERVAL / 2, quark); + avg = TmfStateSystemOperations.queryRangeAverage(ssq, START_TIME - INTERVAL / 2, END_TIME / 2 + INTERVAL / 2, quark); assertEquals((double) (START_TIME + (END_TIME / 2 - INTERVAL)) / 2 / INTERVAL, avg, DELTA); } catch (AttributeNotFoundException e) { fail(e.getMessage()); + } catch (TimeRangeException e) { + fail(e.getMessage()); + } catch (StateValueTypeException e) { + fail(e.getMessage()); } } } diff --git a/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderWeightedTest.java b/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderWeightedTest.java index 95ca5151fe..c75ae7c181 100644 --- a/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderWeightedTest.java +++ b/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/statesystem/mipmap/TmfMipmapStateProviderWeightedTest.java @@ -21,6 +21,7 @@ import org.eclipse.linuxtools.internal.tmf.core.statesystem.backends.IStateHisto import org.eclipse.linuxtools.internal.tmf.core.statesystem.backends.InMemoryBackend; import org.eclipse.linuxtools.tmf.core.exceptions.AttributeNotFoundException; import org.eclipse.linuxtools.tmf.core.exceptions.StateValueTypeException; +import org.eclipse.linuxtools.tmf.core.exceptions.TimeRangeException; import org.eclipse.linuxtools.tmf.core.statesystem.TmfStateSystemOperations; import org.eclipse.linuxtools.tmf.core.statevalue.ITmfStateValue.Type; import org.eclipse.linuxtools.tmf.core.statevalue.TmfStateValue; @@ -39,8 +40,6 @@ public class TmfMipmapStateProviderWeightedTest { private static final double DELTA = 0.0001; private static StateSystem ssqi; private static StateSystem ssqd; - private static TmfStateSystemOperations ssoi; - private static TmfStateSystemOperations ssod; /** * Startup code, build a state system with uneven state durations @@ -51,13 +50,11 @@ public class TmfMipmapStateProviderWeightedTest { TmfMipmapStateProviderStub mmpi = new TmfMipmapStateProviderStub(RESOLUTION, Type.INTEGER); IStateHistoryBackend bei = new InMemoryBackend(0); ssqi = new StateSystem(bei); - ssoi = new TmfStateSystemOperations(ssqi); mmpi.assignTargetStateSystem(ssqi); /* setup for DOUBLE test */ TmfMipmapStateProviderStub mmpd = new TmfMipmapStateProviderStub(RESOLUTION, Type.DOUBLE); IStateHistoryBackend bed = new InMemoryBackend(0); ssqd = new StateSystem(bed); - ssod = new TmfStateSystemOperations(ssqd); mmpd.assignTargetStateSystem(ssqd); /* * Every 10,000 ns chunk contains the following states: @@ -105,24 +102,27 @@ public class TmfMipmapStateProviderWeightedTest { assertNotNull(ssqi); try { int quark = ssqi.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); - assertEquals(TmfStateValue.nullValue(), ssoi.queryRangeMax(0, 0, quark)); - assertEquals(10, ssoi.queryRangeMax(500, 1500, quark).unboxInt()); - assertEquals(20, ssoi.queryRangeMax(1500, 5000, quark).unboxInt()); - assertEquals(30, ssoi.queryRangeMax(5000, 10000, quark).unboxInt()); - assertEquals(30, ssoi.queryRangeMax(0, 10000, quark).unboxInt()); - assertEquals(TmfStateValue.nullValue(), ssoi.queryRangeMax(120000, 120000, quark)); - assertEquals(10, ssoi.queryRangeMax(120500, 121500, quark).unboxInt()); - assertEquals(20, ssoi.queryRangeMax(121500, 125000, quark).unboxInt()); - assertEquals(30, ssoi.queryRangeMax(125000, 130000, quark).unboxInt()); - assertEquals(30, ssoi.queryRangeMax(120000, 130000, quark).unboxInt()); - assertEquals(30, ssoi.queryRangeMax(100000, 150000, quark).unboxInt()); - assertEquals(30, ssoi.queryRangeMax(240000, 250000, quark).unboxInt()); - assertEquals(30, ssoi.queryRangeMax(0, 250000, quark).unboxInt()); - assertEquals(00, ssoi.queryRangeMax(250000, 250000, quark).unboxInt()); + assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMax(ssqi, 0, 0, quark)); + assertEquals(10, TmfStateSystemOperations.queryRangeMax(ssqi, 500, 1500, quark).unboxInt()); + assertEquals(20, TmfStateSystemOperations.queryRangeMax(ssqi, 1500, 5000, quark).unboxInt()); + assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 5000, 10000, quark).unboxInt()); + assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 0, 10000, quark).unboxInt()); + assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMax(ssqi, 120000, 120000, quark)); + assertEquals(10, TmfStateSystemOperations.queryRangeMax(ssqi, 120500, 121500, quark).unboxInt()); + assertEquals(20, TmfStateSystemOperations.queryRangeMax(ssqi, 121500, 125000, quark).unboxInt()); + assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 125000, 130000, quark).unboxInt()); + assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 120000, 130000, quark).unboxInt()); + assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 100000, 150000, quark).unboxInt()); + assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 240000, 250000, quark).unboxInt()); + assertEquals(30, TmfStateSystemOperations.queryRangeMax(ssqi, 0, 250000, quark).unboxInt()); + assertEquals(00, TmfStateSystemOperations.queryRangeMax(ssqi, 250000, 250000, quark).unboxInt()); + } catch (AttributeNotFoundException e) { fail(e.getMessage()); } catch (StateValueTypeException e) { fail(e.getMessage()); + } catch (TimeRangeException e) { + fail(e.getMessage()); } } @@ -135,24 +135,27 @@ public class TmfMipmapStateProviderWeightedTest { assertNotNull(ssqi); try { int quark = ssqi.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); - assertEquals(TmfStateValue.nullValue(), ssoi.queryRangeMin(0, 0, quark)); - assertEquals(10, ssoi.queryRangeMin(500, 1500, quark).unboxInt()); - assertEquals(10, ssoi.queryRangeMin(1500, 5000, quark).unboxInt()); - assertEquals(30, ssoi.queryRangeMin(5000, 10000, quark).unboxInt()); - assertEquals(10, ssoi.queryRangeMin(0, 10000, quark).unboxInt()); - assertEquals(TmfStateValue.nullValue(), ssoi.queryRangeMin(120000, 120000, quark)); - assertEquals(10, ssoi.queryRangeMin(120500, 121500, quark).unboxInt()); - assertEquals(10, ssoi.queryRangeMin(121500, 125000, quark).unboxInt()); - assertEquals(30, ssoi.queryRangeMin(125000, 130000, quark).unboxInt()); - assertEquals(10, ssoi.queryRangeMin(120000, 130000, quark).unboxInt()); - assertEquals(10, ssoi.queryRangeMin(100000, 150000, quark).unboxInt()); - assertEquals(00, ssoi.queryRangeMin(240000, 250000, quark).unboxInt()); - assertEquals(00, ssoi.queryRangeMin(0, 250000, quark).unboxInt()); - assertEquals(00, ssoi.queryRangeMin(250000, 250000, quark).unboxInt()); + assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMin(ssqi, 0, 0, quark)); + assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 500, 1500, quark).unboxInt()); + assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 1500, 5000, quark).unboxInt()); + assertEquals(30, TmfStateSystemOperations.queryRangeMin(ssqi, 5000, 10000, quark).unboxInt()); + assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 0, 10000, quark).unboxInt()); + assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMin(ssqi, 120000, 120000, quark)); + assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 120500, 121500, quark).unboxInt()); + assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 121500, 125000, quark).unboxInt()); + assertEquals(30, TmfStateSystemOperations.queryRangeMin(ssqi, 125000, 130000, quark).unboxInt()); + assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 120000, 130000, quark).unboxInt()); + assertEquals(10, TmfStateSystemOperations.queryRangeMin(ssqi, 100000, 150000, quark).unboxInt()); + assertEquals(00, TmfStateSystemOperations.queryRangeMin(ssqi, 240000, 250000, quark).unboxInt()); + assertEquals(00, TmfStateSystemOperations.queryRangeMin(ssqi, 0, 250000, quark).unboxInt()); + assertEquals(00, TmfStateSystemOperations.queryRangeMin(ssqi, 250000, 250000, quark).unboxInt()); + } catch (AttributeNotFoundException e) { fail(e.getMessage()); } catch (StateValueTypeException e) { fail(e.getMessage()); + } catch (TimeRangeException e) { + fail(e.getMessage()); } } @@ -165,29 +168,34 @@ public class TmfMipmapStateProviderWeightedTest { assertNotNull(ssqi); try { int quark = ssqi.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); - assertEquals(0.0, ssoi.queryRangeAverage(0, 0, quark), DELTA); - assertEquals(5.0, ssoi.queryRangeAverage(500, 1500, quark), DELTA); - assertEquals(90.0 / 7, ssoi.queryRangeAverage(1500, 5000, quark), DELTA); - assertEquals(90.0 / 5, ssoi.queryRangeAverage(5000, 10000, quark), DELTA); - assertEquals(14.0, ssoi.queryRangeAverage(0, 10000, quark), DELTA); - assertEquals(14.0, ssoi.queryRangeAverage(0, 20000, quark), DELTA); - assertEquals(14.0, ssoi.queryRangeAverage(500, 20500, quark), DELTA); - assertEquals(14.0, ssoi.queryRangeAverage(1000, 21000, quark), DELTA); - assertEquals(14.0, ssoi.queryRangeAverage(2000, 22000, quark), DELTA); - assertEquals(14.0, ssoi.queryRangeAverage(3000, 23000, quark), DELTA); - assertEquals(14.0, ssoi.queryRangeAverage(4000, 24000, quark), DELTA); - assertEquals(14.0, ssoi.queryRangeAverage(5000, 25000, quark), DELTA); - assertEquals(0.0, ssoi.queryRangeAverage(120000, 120000, quark), DELTA); - assertEquals(5.0, ssoi.queryRangeAverage(120500, 121500, quark), DELTA); - assertEquals(90.0 / 7, ssoi.queryRangeAverage(121500, 125000, quark), DELTA); - assertEquals(90.0 / 5, ssoi.queryRangeAverage(125000, 130000, quark), DELTA); - assertEquals(14.0, ssoi.queryRangeAverage(120000, 130000, quark), DELTA); - assertEquals(14.0, ssoi.queryRangeAverage(100000, 150000, quark), DELTA); - assertEquals(14.0, ssoi.queryRangeAverage(240000, 250000, quark), DELTA); - assertEquals(14.0, ssoi.queryRangeAverage(0, 250000, quark), DELTA); - assertEquals(0.0, ssoi.queryRangeAverage(250000, 250000, quark), DELTA); + assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 0, 0, quark), DELTA); + assertEquals(5.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 500, 1500, quark), DELTA); + assertEquals(90.0 / 7, TmfStateSystemOperations.queryRangeAverage(ssqi, 1500, 5000, quark), DELTA); + assertEquals(90.0 / 5, TmfStateSystemOperations.queryRangeAverage(ssqi, 5000, 10000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 0, 10000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 0, 20000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 500, 20500, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 1000, 21000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 2000, 22000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 3000, 23000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 4000, 24000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 5000, 25000, quark), DELTA); + assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 120000, 120000, quark), DELTA); + assertEquals(5.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 120500, 121500, quark), DELTA); + assertEquals(90.0 / 7, TmfStateSystemOperations.queryRangeAverage(ssqi, 121500, 125000, quark), DELTA); + assertEquals(90.0 / 5, TmfStateSystemOperations.queryRangeAverage(ssqi, 125000, 130000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 120000, 130000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 100000, 150000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 240000, 250000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 0, 250000, quark), DELTA); + assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqi, 250000, 250000, quark), DELTA); + } catch (AttributeNotFoundException e) { fail(e.getMessage()); + } catch (TimeRangeException e) { + fail(e.getMessage()); + } catch (StateValueTypeException e) { + fail(e.getMessage()); } } @@ -200,24 +208,27 @@ public class TmfMipmapStateProviderWeightedTest { assertNotNull(ssqd); try { int quark = ssqd.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); - assertEquals(TmfStateValue.nullValue(), ssod.queryRangeMax(0, 0, quark)); - assertEquals(10.0, ssod.queryRangeMax(500, 1500, quark).unboxDouble(), DELTA); - assertEquals(20.0, ssod.queryRangeMax(1500, 5000, quark).unboxDouble(), DELTA); - assertEquals(30.0, ssod.queryRangeMax(5000, 10000, quark).unboxDouble(), DELTA); - assertEquals(30.0, ssod.queryRangeMax(0, 10000, quark).unboxDouble(), DELTA); - assertEquals(TmfStateValue.nullValue(), ssod.queryRangeMax(120000, 120000, quark)); - assertEquals(10.0, ssod.queryRangeMax(120500, 121500, quark).unboxDouble(), DELTA); - assertEquals(20.0, ssod.queryRangeMax(121500, 125000, quark).unboxDouble(), DELTA); - assertEquals(30.0, ssod.queryRangeMax(125000, 130000, quark).unboxDouble(), DELTA); - assertEquals(30.0, ssod.queryRangeMax(120000, 130000, quark).unboxDouble(), DELTA); - assertEquals(30.0, ssod.queryRangeMax(100000, 150000, quark).unboxDouble(), DELTA); - assertEquals(30.0, ssod.queryRangeMax(240000, 250000, quark).unboxDouble(), DELTA); - assertEquals(30.0, ssod.queryRangeMax(0, 250000, quark).unboxDouble(), DELTA); - assertEquals(00.0, ssod.queryRangeMax(250000, 250000, quark).unboxDouble(), DELTA); + assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMax(ssqd, 0, 0, quark)); + assertEquals(10.0, TmfStateSystemOperations.queryRangeMax(ssqd, 500, 1500, quark).unboxDouble(), DELTA); + assertEquals(20.0, TmfStateSystemOperations.queryRangeMax(ssqd, 1500, 5000, quark).unboxDouble(), DELTA); + assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 5000, 10000, quark).unboxDouble(), DELTA); + assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 0, 10000, quark).unboxDouble(), DELTA); + assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMax(ssqd, 120000, 120000, quark)); + assertEquals(10.0, TmfStateSystemOperations.queryRangeMax(ssqd, 120500, 121500, quark).unboxDouble(), DELTA); + assertEquals(20.0, TmfStateSystemOperations.queryRangeMax(ssqd, 121500, 125000, quark).unboxDouble(), DELTA); + assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 125000, 130000, quark).unboxDouble(), DELTA); + assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 120000, 130000, quark).unboxDouble(), DELTA); + assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 100000, 150000, quark).unboxDouble(), DELTA); + assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 240000, 250000, quark).unboxDouble(), DELTA); + assertEquals(30.0, TmfStateSystemOperations.queryRangeMax(ssqd, 0, 250000, quark).unboxDouble(), DELTA); + assertEquals(00.0, TmfStateSystemOperations.queryRangeMax(ssqd, 250000, 250000, quark).unboxDouble(), DELTA); + } catch (AttributeNotFoundException e) { fail(e.getMessage()); } catch (StateValueTypeException e) { fail(e.getMessage()); + } catch (TimeRangeException e) { + fail(e.getMessage()); } } @@ -230,24 +241,27 @@ public class TmfMipmapStateProviderWeightedTest { assertNotNull(ssqd); try { int quark = ssqd.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); - assertEquals(TmfStateValue.nullValue(), ssod.queryRangeMin(0, 0, quark)); - assertEquals(10.0, ssod.queryRangeMin(500, 1500, quark).unboxDouble(), DELTA); - assertEquals(10.0, ssod.queryRangeMin(1500, 5000, quark).unboxDouble(), DELTA); - assertEquals(30.0, ssod.queryRangeMin(5000, 10000, quark).unboxDouble(), DELTA); - assertEquals(10.0, ssod.queryRangeMin(0, 10000, quark).unboxDouble(), DELTA); - assertEquals(TmfStateValue.nullValue(), ssod.queryRangeMin(120000, 120000, quark)); - assertEquals(10.0, ssod.queryRangeMin(120500, 121500, quark).unboxDouble(), DELTA); - assertEquals(10.0, ssod.queryRangeMin(121500, 125000, quark).unboxDouble(), DELTA); - assertEquals(30.0, ssod.queryRangeMin(125000, 130000, quark).unboxDouble(), DELTA); - assertEquals(10.0, ssod.queryRangeMin(120000, 130000, quark).unboxDouble(), DELTA); - assertEquals(10.0, ssod.queryRangeMin(100000, 150000, quark).unboxDouble(), DELTA); - assertEquals(00.0, ssod.queryRangeMin(240000, 250000, quark).unboxDouble(), DELTA); - assertEquals(00.0, ssod.queryRangeMin(0, 250000, quark).unboxDouble(), DELTA); - assertEquals(00.0, ssod.queryRangeMin(250000, 250000, quark).unboxDouble(), DELTA); + assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMin(ssqd, 0, 0, quark)); + assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 500, 1500, quark).unboxDouble(), DELTA); + assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 1500, 5000, quark).unboxDouble(), DELTA); + assertEquals(30.0, TmfStateSystemOperations.queryRangeMin(ssqd, 5000, 10000, quark).unboxDouble(), DELTA); + assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 0, 10000, quark).unboxDouble(), DELTA); + assertEquals(TmfStateValue.nullValue(), TmfStateSystemOperations.queryRangeMin(ssqd, 120000, 120000, quark)); + assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 120500, 121500, quark).unboxDouble(), DELTA); + assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 121500, 125000, quark).unboxDouble(), DELTA); + assertEquals(30.0, TmfStateSystemOperations.queryRangeMin(ssqd, 125000, 130000, quark).unboxDouble(), DELTA); + assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 120000, 130000, quark).unboxDouble(), DELTA); + assertEquals(10.0, TmfStateSystemOperations.queryRangeMin(ssqd, 100000, 150000, quark).unboxDouble(), DELTA); + assertEquals(00.0, TmfStateSystemOperations.queryRangeMin(ssqd, 240000, 250000, quark).unboxDouble(), DELTA); + assertEquals(00.0, TmfStateSystemOperations.queryRangeMin(ssqd, 0, 250000, quark).unboxDouble(), DELTA); + assertEquals(00.0, TmfStateSystemOperations.queryRangeMin(ssqd, 250000, 250000, quark).unboxDouble(), DELTA); + } catch (AttributeNotFoundException e) { fail(e.getMessage()); } catch (StateValueTypeException e) { fail(e.getMessage()); + } catch (TimeRangeException e) { + fail(e.getMessage()); } } @@ -260,29 +274,34 @@ public class TmfMipmapStateProviderWeightedTest { assertNotNull(ssqd); try { int quark = ssqd.getQuarkAbsolute(TEST_ATTRIBUTE_NAME); - assertEquals(0.0, ssod.queryRangeAverage(0, 0, quark), DELTA); - assertEquals(5.0, ssod.queryRangeAverage(500, 1500, quark), DELTA); - assertEquals(90.0 / 7, ssod.queryRangeAverage(1500, 5000, quark), DELTA); - assertEquals(90.0 / 5, ssod.queryRangeAverage(5000, 10000, quark), DELTA); - assertEquals(14.0, ssod.queryRangeAverage(0, 10000, quark), DELTA); - assertEquals(14.0, ssod.queryRangeAverage(0, 20000, quark), DELTA); - assertEquals(14.0, ssod.queryRangeAverage(500, 20500, quark), DELTA); - assertEquals(14.0, ssod.queryRangeAverage(1000, 21000, quark), DELTA); - assertEquals(14.0, ssod.queryRangeAverage(2000, 22000, quark), DELTA); - assertEquals(14.0, ssod.queryRangeAverage(3000, 23000, quark), DELTA); - assertEquals(14.0, ssod.queryRangeAverage(4000, 24000, quark), DELTA); - assertEquals(14.0, ssod.queryRangeAverage(5000, 25000, quark), DELTA); - assertEquals(0.0, ssod.queryRangeAverage(120000, 120000, quark), DELTA); - assertEquals(5.0, ssod.queryRangeAverage(120500, 121500, quark), DELTA); - assertEquals(90.0 / 7, ssod.queryRangeAverage(121500, 125000, quark), DELTA); - assertEquals(90.0 / 5, ssod.queryRangeAverage(125000, 130000, quark), DELTA); - assertEquals(14.0, ssod.queryRangeAverage(120000, 130000, quark), DELTA); - assertEquals(14.0, ssod.queryRangeAverage(100000, 150000, quark), DELTA); - assertEquals(14.0, ssod.queryRangeAverage(240000, 250000, quark), DELTA); - assertEquals(14.0, ssod.queryRangeAverage(0, 250000, quark), DELTA); - assertEquals(0.0, ssod.queryRangeAverage(250000, 250000, quark), DELTA); + assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 0, 0, quark), DELTA); + assertEquals(5.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 500, 1500, quark), DELTA); + assertEquals(90.0 / 7, TmfStateSystemOperations.queryRangeAverage(ssqd, 1500, 5000, quark), DELTA); + assertEquals(90.0 / 5, TmfStateSystemOperations.queryRangeAverage(ssqd, 5000, 10000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 0, 10000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 0, 20000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 500, 20500, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 1000, 21000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 2000, 22000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 3000, 23000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 4000, 24000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 5000, 25000, quark), DELTA); + assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 120000, 120000, quark), DELTA); + assertEquals(5.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 120500, 121500, quark), DELTA); + assertEquals(90.0 / 7, TmfStateSystemOperations.queryRangeAverage(ssqd, 121500, 125000, quark), DELTA); + assertEquals(90.0 / 5, TmfStateSystemOperations.queryRangeAverage(ssqd, 125000, 130000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 120000, 130000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 100000, 150000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 240000, 250000, quark), DELTA); + assertEquals(14.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 0, 250000, quark), DELTA); + assertEquals(0.0, TmfStateSystemOperations.queryRangeAverage(ssqd, 250000, 250000, quark), DELTA); + } catch (AttributeNotFoundException e) { fail(e.getMessage()); + } catch (TimeRangeException e) { + fail(e.getMessage()); + } catch (StateValueTypeException e) { + fail(e.getMessage()); } } } diff --git a/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/exceptions/StateValueTypeException.java b/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/exceptions/StateValueTypeException.java index 2aa04d32ab..d1eac0c25f 100644 --- a/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/exceptions/StateValueTypeException.java +++ b/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/exceptions/StateValueTypeException.java @@ -43,4 +43,16 @@ public class StateValueTypeException extends Exception { public StateValueTypeException(String message) { super(message); } + + /** + * Constructor with both a message and a cause. + * + * @param message + * Message to attach to this exception + * @param e + * Cause of this exception + */ + public StateValueTypeException(String message, Throwable e) { + super(message, e); + } } diff --git a/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/statesystem/TmfStateSystemOperations.java b/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/statesystem/TmfStateSystemOperations.java index 5e1d45965f..eb278b4584 100644 --- a/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/statesystem/TmfStateSystemOperations.java +++ b/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/statesystem/TmfStateSystemOperations.java @@ -30,24 +30,18 @@ import org.eclipse.linuxtools.tmf.core.util.Pair; /** * This class implements additional statistical operations that can be * performed on attributes of the state system. + * + * @author Patrick Tassé */ -public class TmfStateSystemOperations { - - private final ITmfStateSystem ss; +public final class TmfStateSystemOperations { - /** - * Constructor - * - * @param ss - * The state system on which to perform operations - */ - public TmfStateSystemOperations(ITmfStateSystem ss) { - this.ss = ss; - } + private TmfStateSystemOperations() {} /** * Return the maximum value of an attribute over a time range * + * @param ss + * The state system to query * @param t1 * The start time of the range * @param t2 @@ -55,28 +49,44 @@ public class TmfStateSystemOperations { * @param quark * The quark of the attribute * @return The maximum value of the attribute in this range + * @throws TimeRangeException + * If an invalid time range is specified + * @throws AttributeNotFoundException + * If the specified quark doesn't match an attribute + * @throws StateValueTypeException + * If the state value type of the attribute does not support the + * "Max" operation */ - public ITmfStateValue queryRangeMax(long t1, long t2, int quark) { + public static ITmfStateValue queryRangeMax(ITmfStateSystem ss, long t1, long t2, int quark) + throws AttributeNotFoundException, TimeRangeException, StateValueTypeException { ITmfStateValue max = TmfStateValue.nullValue(); - try { - List intervals = queryAttributeRange(t1, t2, quark, AbstractTmfMipmapStateProvider.MAX_STRING); - if (intervals.size() == 0) { - return TmfStateValue.nullValue(); - } - for (ITmfStateInterval si : intervals) { - ITmfStateValue value = si.getStateValue(); - if (value.getType() == Type.DOUBLE) { - if (max.isNull() || si.getStateValue().unboxDouble() > max.unboxDouble()) { - max = si.getStateValue(); - } - } else { - if (max.isNull() || si.getStateValue().unboxLong() > max.unboxLong()) { - max = si.getStateValue(); - } + + List intervals = queryAttributeRange(ss, t1, t2, quark, AbstractTmfMipmapStateProvider.MAX_STRING); + if (intervals.size() == 0) { + return TmfStateValue.nullValue(); + } + for (ITmfStateInterval si : intervals) { + ITmfStateValue value = si.getStateValue(); + + switch (value.getType()) { + case DOUBLE: + if (max.isNull() || si.getStateValue().unboxDouble() > max.unboxDouble()) { + max = si.getStateValue(); + } + break; + + case INTEGER: + case LONG: + if (max.isNull() || si.getStateValue().unboxLong() > max.unboxLong()) { + max = si.getStateValue(); } + break; + + case NULL: + case STRING: + default: + throw new StateValueTypeException(); } - } catch (StateValueTypeException e) { - e.printStackTrace(); } return max; } @@ -84,6 +94,8 @@ public class TmfStateSystemOperations { /** * Return the minimum value of an attribute over a time range * + * @param ss + * The state system to query * @param t1 * The start time of the range * @param t2 @@ -91,28 +103,45 @@ public class TmfStateSystemOperations { * @param quark * The quark of the attribute * @return The minimum value of the attribute in this range + * @throws TimeRangeException + * If an invalid time range is specified + * @throws AttributeNotFoundException + * If the specified quark doesn't match an attribute + * @throws StateValueTypeException + * If the state value type of the attribute does not support the + * "Min" operation */ - public ITmfStateValue queryRangeMin(long t1, long t2, int quark) { + public static ITmfStateValue queryRangeMin(ITmfStateSystem ss, + long t1, long t2, int quark) + throws AttributeNotFoundException, TimeRangeException, StateValueTypeException { ITmfStateValue min = TmfStateValue.nullValue(); - try { - List intervals = queryAttributeRange(t1, t2, quark, AbstractTmfMipmapStateProvider.MIN_STRING); - if (intervals.size() == 0) { - return TmfStateValue.nullValue(); - } - for (ITmfStateInterval si : intervals) { - ITmfStateValue value = si.getStateValue(); - if (value.getType() == Type.DOUBLE) { - if (min.isNull() || si.getStateValue().unboxDouble() < min.unboxDouble()) { - min = si.getStateValue(); - } - } else { - if (min.isNull() || si.getStateValue().unboxLong() < min.unboxLong()) { - min = si.getStateValue(); - } + + List intervals = queryAttributeRange(ss, t1, t2, quark, AbstractTmfMipmapStateProvider.MIN_STRING); + if (intervals.size() == 0) { + return TmfStateValue.nullValue(); + } + for (ITmfStateInterval si : intervals) { + ITmfStateValue value = si.getStateValue(); + + switch (value.getType()) { + case DOUBLE: + if (min.isNull() || si.getStateValue().unboxDouble() < min.unboxDouble()) { + min = si.getStateValue(); + } + break; + + case INTEGER: + case LONG: + if (min.isNull() || si.getStateValue().unboxLong() < min.unboxLong()) { + min = si.getStateValue(); } + break; + + case NULL: + case STRING: + default: + throw new StateValueTypeException(); } - } catch (StateValueTypeException e) { - e.printStackTrace(); } return min; } @@ -120,6 +149,8 @@ public class TmfStateSystemOperations { /** * Return the weighted average value of an attribute over a time range * + * @param ss + * The state system to query * @param t1 * The start time of the range * @param t2 @@ -127,40 +158,46 @@ public class TmfStateSystemOperations { * @param quark * The quark of the attribute * @return The weighted average value of the attribute in this range + * @throws TimeRangeException + * If an invalid time range is specified + * @throws AttributeNotFoundException + * If the specified quark doesn't match an attribute + * @throws StateValueTypeException + * If the state value type of the attribute does not support the + * "Average" operation */ - public double queryRangeAverage(long t1, long t2, int quark) { + public static double queryRangeAverage(ITmfStateSystem ss, long t1, long t2, int quark) + throws AttributeNotFoundException, TimeRangeException, StateValueTypeException { double avg = 0.0; - try { - List intervals = queryAttributeRange(t1, t2, quark, AbstractTmfMipmapStateProvider.AVG_STRING); - if (intervals.size() == 0) { - return 0; - } else if (t1 == t2) { - ITmfStateValue value = intervals.get(0).getStateValue(); - if (value.getType() == Type.DOUBLE) { - return value.unboxDouble(); - } - return value.unboxLong(); + List intervals = queryAttributeRange(ss, t1, t2, quark, AbstractTmfMipmapStateProvider.AVG_STRING); + if (intervals.size() == 0) { + return 0; + } else if (t1 == t2) { + ITmfStateValue value = intervals.get(0).getStateValue(); + if (value.getType() == Type.DOUBLE) { + return value.unboxDouble(); } - for (ITmfStateInterval si : intervals) { - long startTime = Math.max(t1, si.getStartTime()); - long endTime = Math.min(t2, si.getEndTime() + 1); - long delta = endTime - startTime; - if (delta > 0) { - ITmfStateValue value = si.getStateValue(); - if (value.getType() == Type.DOUBLE) { - avg += si.getStateValue().unboxDouble() * ((double) delta / (double) (t2 - t1)); - } else { - avg += si.getStateValue().unboxLong() * ((double) delta / (double) (t2 - t1)); - } + return value.unboxLong(); + } + for (ITmfStateInterval si : intervals) { + long startTime = Math.max(t1, si.getStartTime()); + long endTime = Math.min(t2, si.getEndTime() + 1); + long delta = endTime - startTime; + if (delta > 0) { + ITmfStateValue value = si.getStateValue(); + if (value.getType() == Type.DOUBLE) { + avg += si.getStateValue().unboxDouble() * ((double) delta / (double) (t2 - t1)); + } else { + avg += si.getStateValue().unboxLong() * ((double) delta / (double) (t2 - t1)); } } - } catch (StateValueTypeException e) { - e.printStackTrace(); } return avg; } - private List queryAttributeRange(long t1, long t2, int baseQuark, String featureString) { + private static List queryAttributeRange(ITmfStateSystem ss, + long t1, long t2, int baseQuark, String featureString) + throws AttributeNotFoundException, TimeRangeException, StateValueTypeException { Pair timeRange = new Pair(t1, t2); int mipmapQuark = -1; List intervals = new ArrayList(); @@ -185,21 +222,23 @@ public class TmfStateSystemOperations { } ITmfStateInterval maxLevelInterval = ss.querySingleState(timeRange.getSecond(), mipmapQuark); int levelMax = maxLevelInterval.getStateValue().unboxInt(); - queryMipmapAttributeRange(0, levelMax, baseQuark, mipmapQuark, timeRange, intervals); + queryMipmapAttributeRange(ss, 0, levelMax, baseQuark, mipmapQuark, timeRange, intervals); return intervals; - } catch (AttributeNotFoundException e) { - e.printStackTrace(); - } catch (TimeRangeException e) { - e.printStackTrace(); + } catch (StateValueTypeException e) { - e.printStackTrace(); + /* This is a special case, so we'll add a message to the exception */ + throw new StateValueTypeException("State system advertises mipmaps," + //$NON-NLS-1$ + " but doesn't actually have them.", e); //$NON-NLS-1$ } catch (StateSystemDisposedException e) { - /* Ignored */ + /* We are shutting down, ignore the operation */ } return intervals; } - private void queryMipmapAttributeRange(int currentLevel, int levelMax, int baseQuark, int mipmapQuark, Pair timeRange, List intervals) { + private static void queryMipmapAttributeRange(ITmfStateSystem ss, + int currentLevel, int levelMax, int baseQuark, int mipmapQuark, + Pair timeRange, List intervals) + throws AttributeNotFoundException, TimeRangeException { int level = currentLevel; Pair range = timeRange; ITmfStateInterval currentLevelInterval = null, nextLevelInterval = null; @@ -229,7 +268,7 @@ public class TmfStateSystemOperations { } else { level++; } - queryMipmapAttributeRange(level, levelMax, baseQuark, mipmapQuark, range, intervals); + queryMipmapAttributeRange(ss, level, levelMax, baseQuark, mipmapQuark, range, intervals); return; } @@ -259,33 +298,34 @@ public class TmfStateSystemOperations { } } - queryMipmapAttributeRange(level, levelMax, baseQuark, mipmapQuark, range, intervals); + queryMipmapAttributeRange(ss, level, levelMax, baseQuark, + mipmapQuark, range, intervals); - } catch (AttributeNotFoundException e) { - e.printStackTrace(); - } catch (TimeRangeException e) { - e.printStackTrace(); } catch (StateSystemDisposedException e) { - /* Ignored */ + /* We are shutting down, ignore the operation */ } } - private static Pair updateTimeRange(Pair timeRange, ITmfStateInterval currentLevelInterval) { + private static Pair updateTimeRange(Pair timeRange, + ITmfStateInterval currentLevelInterval) { if (currentLevelInterval.getEndTime() >= timeRange.getSecond()) { return null; } - long startTime = Math.max(timeRange.getFirst(), Math.min(currentLevelInterval.getEndTime() + 1, timeRange.getSecond())); + long startTime = Math.max(timeRange.getFirst(), + Math.min(currentLevelInterval.getEndTime() + 1, timeRange.getSecond())); return new Pair(startTime, timeRange.getSecond()); } - private static boolean isFullyOverlapped(Pair range, ITmfStateInterval interval) { - if (range.getFirst() >= range.getSecond() || interval.getStartTime() >= interval.getEndTime()) { + private static boolean isFullyOverlapped(Pair range, + ITmfStateInterval interval) { + if (range.getFirst() >= range.getSecond() || + interval.getStartTime() >= interval.getEndTime()) { return false; } - if (range.getFirst() <= interval.getStartTime() && range.getSecond() >= interval.getEndTime()) { + if (range.getFirst() <= interval.getStartTime() && + range.getSecond() >= interval.getEndTime()) { return true; } return false; } - }