From: Geneviève Bastien Date: Wed, 10 May 2017 14:50:17 +0000 (-0400) Subject: segStore: Merge ISegment and ISegment2 X-Git-Url: http://git.efficios.com/?p=deliverable%2Ftracecompass.git;a=commitdiff_plain;h=3866be8e231ba046fdf853ad61fe5ccf72bcd24b segStore: Merge ISegment and ISegment2 This breaks the API of ISegment, but makes all segments serializable in an on disk segment store backend. Change-Id: I6282f695c5f20f78a7ac929f43a41fed8a7019e0 Signed-off-by: Geneviève Bastien Reviewed-on: https://git.eclipse.org/r/96746 Reviewed-by: Matthew Khouzam Tested-by: Matthew Khouzam Reviewed-by: Hudson CI --- diff --git a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/META-INF/MANIFEST.MF b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/META-INF/MANIFEST.MF index 8aa91e6111..a8cd95d03b 100644 --- a/analysis/org.eclipse.tracecompass.analysis.os.linux.core/META-INF/MANIFEST.MF +++ b/analysis/org.eclipse.tracecompass.analysis.os.linux.core/META-INF/MANIFEST.MF @@ -12,6 +12,7 @@ Require-Bundle: org.eclipse.core.runtime, org.eclipse.core.resources, org.eclipse.tracecompass.common.core, org.eclipse.tracecompass.tmf.core, + org.eclipse.tracecompass.datastore.core, org.eclipse.tracecompass.segmentstore.core, org.eclipse.tracecompass.analysis.timing.core, org.eclipse.tracecompass.statesystem.core diff --git a/analysis/org.eclipse.tracecompass.analysis.timing.core.tests/META-INF/MANIFEST.MF b/analysis/org.eclipse.tracecompass.analysis.timing.core.tests/META-INF/MANIFEST.MF index f00b3bb3d3..39d1011684 100644 --- a/analysis/org.eclipse.tracecompass.analysis.timing.core.tests/META-INF/MANIFEST.MF +++ b/analysis/org.eclipse.tracecompass.analysis.timing.core.tests/META-INF/MANIFEST.MF @@ -11,6 +11,7 @@ Require-Bundle: org.junit;bundle-version="4.0.0", org.eclipse.core.runtime, org.eclipse.tracecompass.common.core, org.eclipse.tracecompass.analysis.os.linux.core, + org.eclipse.tracecompass.datastore.core, org.eclipse.tracecompass.segmentstore.core, org.eclipse.tracecompass.tmf.core, org.eclipse.tracecompass.tmf.core.tests, diff --git a/analysis/org.eclipse.tracecompass.analysis.timing.core/META-INF/MANIFEST.MF b/analysis/org.eclipse.tracecompass.analysis.timing.core/META-INF/MANIFEST.MF index 2f64ca05c9..eb18b07c13 100644 --- a/analysis/org.eclipse.tracecompass.analysis.timing.core/META-INF/MANIFEST.MF +++ b/analysis/org.eclipse.tracecompass.analysis.timing.core/META-INF/MANIFEST.MF @@ -13,6 +13,7 @@ Require-Bundle: org.eclipse.ui, org.eclipse.core.resources, org.eclipse.tracecompass.common.core, org.eclipse.tracecompass.tmf.core, + org.eclipse.tracecompass.datastore.core, org.eclipse.tracecompass.segmentstore.core Export-Package: org.eclipse.tracecompass.analysis.timing.core.segmentstore, org.eclipse.tracecompass.analysis.timing.core.segmentstore.statistics, diff --git a/analysis/org.eclipse.tracecompass.analysis.timing.ui.swtbot.tests/META-INF/MANIFEST.MF b/analysis/org.eclipse.tracecompass.analysis.timing.ui.swtbot.tests/META-INF/MANIFEST.MF index 7e30d19744..c332a0796f 100644 --- a/analysis/org.eclipse.tracecompass.analysis.timing.ui.swtbot.tests/META-INF/MANIFEST.MF +++ b/analysis/org.eclipse.tracecompass.analysis.timing.ui.swtbot.tests/META-INF/MANIFEST.MF @@ -30,6 +30,7 @@ Require-Bundle: org.apache.log4j, org.junit, org.eclipse.tracecompass.analysis.timing.core.tests, org.eclipse.tracecompass.tmf.ui.tests, + org.eclipse.tracecompass.datastore.core, org.eclipse.tracecompass.segmentstore.core, org.eclipse.tracecompass.datastore.core Import-Package: com.google.common.collect, diff --git a/analysis/org.eclipse.tracecompass.analysis.timing.ui.swtbot.tests/src/org/eclipse/tracecompass/analysis/timing/ui/swtbot/tests/table/SegmentTableTest.java b/analysis/org.eclipse.tracecompass.analysis.timing.ui.swtbot.tests/src/org/eclipse/tracecompass/analysis/timing/ui/swtbot/tests/table/SegmentTableTest.java index 235416737d..73ec2d5499 100644 --- a/analysis/org.eclipse.tracecompass.analysis.timing.ui.swtbot.tests/src/org/eclipse/tracecompass/analysis/timing/ui/swtbot/tests/table/SegmentTableTest.java +++ b/analysis/org.eclipse.tracecompass.analysis.timing.ui.swtbot.tests/src/org/eclipse/tracecompass/analysis/timing/ui/swtbot/tests/table/SegmentTableTest.java @@ -46,7 +46,6 @@ import org.eclipse.tracecompass.analysis.timing.core.segmentstore.IAnalysisProgr import org.eclipse.tracecompass.analysis.timing.core.segmentstore.ISegmentStoreProvider; import org.eclipse.tracecompass.analysis.timing.ui.views.segmentstore.table.AbstractSegmentStoreTableView; import org.eclipse.tracecompass.analysis.timing.ui.views.segmentstore.table.AbstractSegmentStoreTableViewer; -import org.eclipse.tracecompass.internal.provisional.segmentstore.core.BasicSegment2; import org.eclipse.tracecompass.segmentstore.core.BasicSegment; import org.eclipse.tracecompass.segmentstore.core.ISegment; import org.eclipse.tracecompass.segmentstore.core.ISegmentStore; @@ -403,9 +402,9 @@ public class SegmentTableTest { Path segmentFile = Files.createTempFile("tmpSegStore", ".tmp"); try { final int size = 1000000; - ISegmentStore<@NonNull BasicSegment2> fixture = SegmentStoreFactory.createOnDiskSegmentStore(segmentFile, BasicSegment2.BASIC_SEGMENT_READ_FACTORY); + ISegmentStore<@NonNull BasicSegment> fixture = SegmentStoreFactory.createOnDiskSegmentStore(segmentFile, BasicSegment.BASIC_SEGMENT_READ_FACTORY); for (int i = 0; i < size; i++) { - fixture.add(new BasicSegment2(i, 2 * i)); + fixture.add(new BasicSegment(i, 2 * i)); } assertNotNull(getTable()); getTable().updateModel(fixture); diff --git a/analysis/org.eclipse.tracecompass.analysis.timing.ui/META-INF/MANIFEST.MF b/analysis/org.eclipse.tracecompass.analysis.timing.ui/META-INF/MANIFEST.MF index bbf04ecb91..92374c108e 100644 --- a/analysis/org.eclipse.tracecompass.analysis.timing.ui/META-INF/MANIFEST.MF +++ b/analysis/org.eclipse.tracecompass.analysis.timing.ui/META-INF/MANIFEST.MF @@ -13,6 +13,7 @@ Require-Bundle: org.eclipse.ui, com.google.guava, org.eclipse.tracecompass.analysis.timing.core, org.eclipse.tracecompass.common.core, + org.eclipse.tracecompass.datastore.core, org.eclipse.tracecompass.segmentstore.core, org.eclipse.tracecompass.tmf.core, org.eclipse.tracecompass.tmf.ui, diff --git a/lttng/org.eclipse.tracecompass.lttng2.kernel.core.tests/META-INF/MANIFEST.MF b/lttng/org.eclipse.tracecompass.lttng2.kernel.core.tests/META-INF/MANIFEST.MF index d08d7b8337..291bfffc39 100644 --- a/lttng/org.eclipse.tracecompass.lttng2.kernel.core.tests/META-INF/MANIFEST.MF +++ b/lttng/org.eclipse.tracecompass.lttng2.kernel.core.tests/META-INF/MANIFEST.MF @@ -22,6 +22,7 @@ Require-Bundle: org.junit;bundle-version="4.0.0", org.eclipse.tracecompass.analysis.os.linux.core.tests, org.eclipse.tracecompass.analysis.graph.core, org.eclipse.tracecompass.analysis.timing.core, + org.eclipse.tracecompass.datastore.core, org.eclipse.tracecompass.segmentstore.core Export-Package: org.eclipse.tracecompass.lttng2.kernel.core.tests, org.eclipse.tracecompass.lttng2.kernel.core.tests.analysis.graph, @@ -36,6 +37,8 @@ Export-Package: org.eclipse.tracecompass.lttng2.kernel.core.tests, org.eclipse.tracecompass.lttng2.kernel.core.tests.perf.analysis.tid, org.eclipse.tracecompass.lttng2.kernel.core.tests.perf.event.matching, org.eclipse.tracecompass.lttng2.kernel.core.tests.stubs, + org.eclipse.tracecompass.lttng2.kernel.core.tests.synchronization, + org.eclipse.tracecompass.lttng2.lttng.kernel.core.tests.shared, org.eclipse.tracecompass.lttng2.lttng.kernel.core.tests.shared.vm Import-Package: com.google.common.collect, org.eclipse.test.performance, diff --git a/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/perf/org/eclipse/tracecompass/segmentstore/core/tests/perf/SegmentStoreBenchmark.java b/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/perf/org/eclipse/tracecompass/segmentstore/core/tests/perf/SegmentStoreBenchmark.java index 114e94474e..6930b9d409 100644 --- a/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/perf/org/eclipse/tracecompass/segmentstore/core/tests/perf/SegmentStoreBenchmark.java +++ b/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/perf/org/eclipse/tracecompass/segmentstore/core/tests/perf/SegmentStoreBenchmark.java @@ -23,10 +23,10 @@ import org.eclipse.jdt.annotation.NonNullByDefault; import org.eclipse.test.performance.Performance; import org.eclipse.test.performance.PerformanceMeter; import org.eclipse.tracecompass.common.core.NonNullUtils; -import org.eclipse.tracecompass.internal.provisional.segmentstore.core.BasicSegment2; import org.eclipse.tracecompass.internal.segmentstore.core.arraylist.ArrayListStore; import org.eclipse.tracecompass.internal.segmentstore.core.arraylist.LazyArrayListStore; import org.eclipse.tracecompass.internal.segmentstore.core.treemap.TreeMapStore; +import org.eclipse.tracecompass.segmentstore.core.BasicSegment; import org.eclipse.tracecompass.segmentstore.core.ISegment; import org.eclipse.tracecompass.segmentstore.core.ISegmentStore; import org.eclipse.tracecompass.segmentstore.core.SegmentComparators; @@ -57,7 +57,7 @@ public class SegmentStoreBenchmark { private static final int DEFAULT_SAMPLE = 1000; private static final int DEFAULT_LOOP_COUNT = 10; - private final ISegmentStore<@NonNull BasicSegment2> fSegStore; + private final ISegmentStore<@NonNull BasicSegment> fSegStore; private final String fName; private final Performance fPerf; @@ -72,7 +72,7 @@ public class SegmentStoreBenchmark { { "Array list store", new ArrayListStore<>() }, { "Lazy array list store", new LazyArrayListStore<>() }, { "Treemap store", new TreeMapStore<>() }, - { "HT store", new HistoryTreeSegmentStoreStub<>(NonNullUtils.checkNotNull(Files.createTempFile("tmpSegStore", null)), 0, BasicSegment2.BASIC_SEGMENT_READ_FACTORY) }, + { "HT store", new HistoryTreeSegmentStoreStub<>(NonNullUtils.checkNotNull(Files.createTempFile("tmpSegStore", null)), 0, BasicSegment.BASIC_SEGMENT_READ_FACTORY) }, }); } @@ -84,7 +84,7 @@ public class SegmentStoreBenchmark { * @param segStore * The segment store to fill for the benchmarks */ - public SegmentStoreBenchmark(String name, ISegmentStore<@NonNull BasicSegment2> segStore) { + public SegmentStoreBenchmark(String name, ISegmentStore<@NonNull BasicSegment> segStore) { fSegStore = segStore; fName = name; fPerf = NonNullUtils.checkNotNull(Performance.getDefault()); @@ -244,9 +244,9 @@ public class SegmentStoreBenchmark { pMiterate2.commit(); } - private static int iterate(Iterable<@NonNull BasicSegment2> store) { + private static int iterate(Iterable<@NonNull BasicSegment> store) { int count = 0; - Iterator<@NonNull BasicSegment2> iterator = store.iterator(); + Iterator<@NonNull BasicSegment> iterator = store.iterator(); while (iterator.hasNext()) { count++; iterator.next(); @@ -254,15 +254,15 @@ public class SegmentStoreBenchmark { return count; } - private static int sortedIterate(ISegmentStore<@NonNull BasicSegment2> store, Comparator order) { - Iterable<@NonNull BasicSegment2> iterable = store.iterator(order); + private static int sortedIterate(ISegmentStore<@NonNull BasicSegment> store, Comparator order) { + Iterable<@NonNull BasicSegment> iterable = store.iterator(order); return iterate(iterable); } - private static void populate(int size, int[] fuzz, ISegmentStore<@NonNull BasicSegment2> store, long low, long high) { + private static void populate(int size, int[] fuzz, ISegmentStore<@NonNull BasicSegment> store, long low, long high) { for (long i = low; i < high; i++) { long start = i + fuzz[(int) (i % size)]; - store.add(new BasicSegment2(start, start + 10)); + store.add(new BasicSegment(start, start + 10)); } } } \ No newline at end of file diff --git a/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/perf/org/eclipse/tracecompass/segmentstore/core/tests/perf/SegmentStoreBigBenchmark.java b/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/perf/org/eclipse/tracecompass/segmentstore/core/tests/perf/SegmentStoreBigBenchmark.java index a70cb08311..06b917b97f 100644 --- a/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/perf/org/eclipse/tracecompass/segmentstore/core/tests/perf/SegmentStoreBigBenchmark.java +++ b/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/perf/org/eclipse/tracecompass/segmentstore/core/tests/perf/SegmentStoreBigBenchmark.java @@ -15,7 +15,7 @@ import java.util.Arrays; import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.NonNullByDefault; -import org.eclipse.tracecompass.internal.provisional.segmentstore.core.BasicSegment2; +import org.eclipse.tracecompass.segmentstore.core.BasicSegment; import org.eclipse.tracecompass.segmentstore.core.ISegmentStore; import org.eclipse.tracecompass.segmentstore.core.tests.historytree.HistoryTreeSegmentStoreStub; import org.junit.runners.Parameterized.Parameters; @@ -36,7 +36,7 @@ public class SegmentStoreBigBenchmark extends SegmentStoreBenchmark { * @param segStore * The segment store to use */ - public SegmentStoreBigBenchmark(String name, ISegmentStore<@NonNull BasicSegment2> segStore) { + public SegmentStoreBigBenchmark(String name, ISegmentStore<@NonNull BasicSegment> segStore) { super(name, segStore); } @@ -48,7 +48,7 @@ public class SegmentStoreBigBenchmark extends SegmentStoreBenchmark { @Parameters(name = "{index}: {0}") public static Iterable getParameters() throws IOException { return Arrays.asList(new Object[][] { - { "HT store", new HistoryTreeSegmentStoreStub<>(Files.createTempFile("tmpSegStore", null), 1, BasicSegment2.BASIC_SEGMENT_READ_FACTORY) }, + { "HT store", new HistoryTreeSegmentStoreStub<>(Files.createTempFile("tmpSegStore", null), 1, BasicSegment.BASIC_SEGMENT_READ_FACTORY) }, }); } diff --git a/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/src/org/eclipse/tracecompass/segmentstore/core/tests/AbstractTestSegmentStore.java b/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/src/org/eclipse/tracecompass/segmentstore/core/tests/AbstractTestSegmentStore.java index cb97a813db..5e173957a5 100644 --- a/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/src/org/eclipse/tracecompass/segmentstore/core/tests/AbstractTestSegmentStore.java +++ b/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/src/org/eclipse/tracecompass/segmentstore/core/tests/AbstractTestSegmentStore.java @@ -28,7 +28,6 @@ import org.eclipse.tracecompass.common.core.NonNullUtils; import org.eclipse.tracecompass.datastore.core.interval.IHTIntervalReader; import org.eclipse.tracecompass.datastore.core.serialization.ISafeByteBufferWriter; import org.eclipse.tracecompass.datastore.core.serialization.SafeByteBufferFactory; -import org.eclipse.tracecompass.internal.provisional.segmentstore.core.ISegment2; import org.eclipse.tracecompass.segmentstore.core.BasicSegment; import org.eclipse.tracecompass.segmentstore.core.ISegment; import org.eclipse.tracecompass.segmentstore.core.ISegmentStore; @@ -90,7 +89,7 @@ public abstract class AbstractTestSegmentStore { * * @author Geneviève Bastien */ - protected static final class TestSegment implements ISegment2 { + protected static final class TestSegment implements ISegment { /** * The reader for this class diff --git a/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/src/org/eclipse/tracecompass/segmentstore/core/tests/htStore/SegmentHistoryTreeTest.java b/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/src/org/eclipse/tracecompass/segmentstore/core/tests/htStore/SegmentHistoryTreeTest.java index a7e9ffc029..c8bf6960b6 100644 --- a/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/src/org/eclipse/tracecompass/segmentstore/core/tests/htStore/SegmentHistoryTreeTest.java +++ b/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/src/org/eclipse/tracecompass/segmentstore/core/tests/htStore/SegmentHistoryTreeTest.java @@ -24,9 +24,9 @@ import org.eclipse.jdt.annotation.NonNullByDefault; import org.eclipse.tracecompass.common.core.NonNullUtils; import org.eclipse.tracecompass.internal.provisional.datastore.core.historytree.AbstractHistoryTree; import org.eclipse.tracecompass.internal.provisional.datastore.core.historytree.overlapping.AbstractOverlappingHistoryTreeTestBase; -import org.eclipse.tracecompass.internal.provisional.segmentstore.core.BasicSegment2; import org.eclipse.tracecompass.internal.segmentstore.core.segmentHistoryTree.SegmentHistoryTree; import org.eclipse.tracecompass.internal.segmentstore.core.segmentHistoryTree.SegmentTreeNode; +import org.eclipse.tracecompass.segmentstore.core.BasicSegment; import org.eclipse.tracecompass.segmentstore.core.tests.historytree.SegmentHistoryTreeStub; import org.junit.Test; @@ -39,34 +39,34 @@ import com.google.common.collect.Iterators; * @author Geneviève Bastien */ @NonNullByDefault -public class SegmentHistoryTreeTest extends AbstractOverlappingHistoryTreeTestBase> { +public class SegmentHistoryTreeTest extends AbstractOverlappingHistoryTreeTestBase> { - private static final BasicSegment2 DEFAULT_OBJECT = new BasicSegment2(0, 0); + private static final BasicSegment DEFAULT_OBJECT = new BasicSegment(0, 0); @Override - protected SegmentHistoryTreeStub createHistoryTree(@NonNull File stateHistoryFile, int blockSize, int maxChildren, int providerVersion, long treeStart) + protected SegmentHistoryTreeStub createHistoryTree(@NonNull File stateHistoryFile, int blockSize, int maxChildren, int providerVersion, long treeStart) throws IOException { return new SegmentHistoryTreeStub<>(stateHistoryFile, blockSize, maxChildren, providerVersion, treeStart, - BasicSegment2.BASIC_SEGMENT_READ_FACTORY); + BasicSegment.BASIC_SEGMENT_READ_FACTORY); } @Override - protected SegmentHistoryTreeStub createHistoryTree(@NonNull File existingStateFile, int expectedProviderVersion) throws IOException { + protected SegmentHistoryTreeStub createHistoryTree(@NonNull File existingStateFile, int expectedProviderVersion) throws IOException { return new SegmentHistoryTreeStub<>(existingStateFile, expectedProviderVersion, - BasicSegment2.BASIC_SEGMENT_READ_FACTORY); + BasicSegment.BASIC_SEGMENT_READ_FACTORY); } @Override - protected BasicSegment2 createInterval(long start, long end) { - return new BasicSegment2(start, end); + protected BasicSegment createInterval(long start, long end) { + return new BasicSegment(start, end); } @Override - protected long fillValues(@NonNull AbstractHistoryTree<@NonNull BasicSegment2, SegmentTreeNode<@NonNull BasicSegment2>> ht, int fillSize, long start) { + protected long fillValues(@NonNull AbstractHistoryTree<@NonNull BasicSegment, SegmentTreeNode<@NonNull BasicSegment>> ht, int fillSize, long start) { int nbValues = fillSize / DEFAULT_OBJECT.getSizeOnDisk(); for (int i = 0; i < nbValues; i++) { ht.insert(createInterval(start + i, start + i + 1)); @@ -80,7 +80,7 @@ public class SegmentHistoryTreeTest extends AbstractOverlappingHistoryTreeTestBa @Test public void testIsEmpty() { long start = 10L; - SegmentHistoryTreeStub oht = (SegmentHistoryTreeStub) setupSmallTree(3, start); + SegmentHistoryTreeStub oht = (SegmentHistoryTreeStub) setupSmallTree(3, start); assertTrue(oht.isEmpty()); @@ -89,7 +89,7 @@ public class SegmentHistoryTreeTest extends AbstractOverlappingHistoryTreeTestBa assertFalse(oht.isEmpty()); /* Fill a first node */ - SegmentTreeNode node = oht.getLatestLeaf(); + SegmentTreeNode node = oht.getLatestLeaf(); long time = fillValues(oht, node.getNodeFreeSpace(), start); /* @@ -109,7 +109,7 @@ public class SegmentHistoryTreeTest extends AbstractOverlappingHistoryTreeTestBa @Test public void testSizeAndIterator() throws IOException { long start = 10L; - SegmentHistoryTreeStub oht = (SegmentHistoryTreeStub) setupSmallTree(3, start); + SegmentHistoryTreeStub oht = (SegmentHistoryTreeStub) setupSmallTree(3, start); int nbSegments = 0; assertEquals(nbSegments, oht.size()); @@ -120,7 +120,7 @@ public class SegmentHistoryTreeTest extends AbstractOverlappingHistoryTreeTestBa assertEquals(nbSegments, oht.size()); /* Fill a first node */ - SegmentTreeNode node = oht.getLatestLeaf(); + SegmentTreeNode node = oht.getLatestLeaf(); nbSegments += node.getNodeFreeSpace() / DEFAULT_OBJECT.getSizeOnDisk(); long time = fillValues(oht, node.getNodeFreeSpace(), start); assertEquals(nbSegments, oht.size()); @@ -149,24 +149,24 @@ public class SegmentHistoryTreeTest extends AbstractOverlappingHistoryTreeTestBa oht.closeTree(oht.getTreeEnd()); // Create a reader history tree - oht = (SegmentHistoryTreeStub) createHistoryTreeReader(); + oht = (SegmentHistoryTreeStub) createHistoryTreeReader(); assertEquals(nbSegments, oht.size()); // Test the iterator on that tree - Iterator iterator = oht.iterator(); + Iterator iterator = oht.iterator(); assertNotNull(iterator); int count = Iterators.size(iterator); assertEquals(nbSegments, count); // Test the intersecting elements - Iterable intersectingElements = oht.getIntersectingElements(start, time); + Iterable intersectingElements = oht.getIntersectingElements(start, time); count = 0; // While doing this iterator, count the number of segments of a smaller // time range, it will be needed later long rangeStart = (long) (start + (time - start) * 0.4); long rangeEnd = (long) (time - (time - start) * 0.4); int nbInRange = 0; - for (BasicSegment2 segment : intersectingElements) { + for (BasicSegment segment : intersectingElements) { count++; if (segment.getStart() <= rangeEnd && rangeStart <= segment.getEnd()) { nbInRange++; @@ -179,22 +179,22 @@ public class SegmentHistoryTreeTest extends AbstractOverlappingHistoryTreeTestBa assertEquals(nbInRange, count); // Test intersecting elements with start time ordering - Comparator cmp = NonNullUtils.checkNotNull(Comparator.comparing(BasicSegment2::getStart)); + Comparator cmp = NonNullUtils.checkNotNull(Comparator.comparing(BasicSegment::getStart)); assertSortedIteration(oht, rangeStart, rangeEnd, cmp, nbInRange); // Test intersecting elements with end time ordering - cmp = NonNullUtils.checkNotNull(Comparator.comparing(BasicSegment2::getEnd)); + cmp = NonNullUtils.checkNotNull(Comparator.comparing(BasicSegment::getEnd)); assertSortedIteration(oht, rangeStart, rangeEnd, cmp, nbInRange); // Test intersecting elements with duration ordering - cmp = NonNullUtils.checkNotNull(Comparator.comparing(BasicSegment2::getLength)); + cmp = NonNullUtils.checkNotNull(Comparator.comparing(BasicSegment::getLength)); assertSortedIteration(oht, rangeStart, rangeEnd, cmp, nbInRange); } - private static void assertSortedIteration(SegmentHistoryTreeStub<@NonNull BasicSegment2> oht, long rangeStart, long rangeEnd, Comparator<@NonNull BasicSegment2> cmp, int nbInRange) { + private static void assertSortedIteration(SegmentHistoryTreeStub<@NonNull BasicSegment> oht, long rangeStart, long rangeEnd, Comparator<@NonNull BasicSegment> cmp, int nbInRange) { int count = 0; - BasicSegment2 prev = DEFAULT_OBJECT; - for (BasicSegment2 segment : oht.getIntersectingElements(rangeStart, rangeEnd, cmp)) { + BasicSegment prev = DEFAULT_OBJECT; + for (BasicSegment segment : oht.getIntersectingElements(rangeStart, rangeEnd, cmp)) { count++; assertTrue("Segment comparison at " + count, cmp.compare(prev, segment) <= 0); } diff --git a/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/src/org/eclipse/tracecompass/segmentstore/core/tests/htStore/SegmentTreeCoreNodeTest.java b/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/src/org/eclipse/tracecompass/segmentstore/core/tests/htStore/SegmentTreeCoreNodeTest.java index 86004407c9..9c7e4a360d 100644 --- a/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/src/org/eclipse/tracecompass/segmentstore/core/tests/htStore/SegmentTreeCoreNodeTest.java +++ b/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/src/org/eclipse/tracecompass/segmentstore/core/tests/htStore/SegmentTreeCoreNodeTest.java @@ -22,8 +22,8 @@ import org.eclipse.tracecompass.internal.provisional.datastore.core.condition.Ti import org.eclipse.tracecompass.internal.provisional.datastore.core.historytree.AbstractHistoryTree.IHTNodeFactory; import org.eclipse.tracecompass.internal.provisional.datastore.core.historytree.HTCoreNodeTest; import org.eclipse.tracecompass.internal.provisional.datastore.core.historytree.HTNode; -import org.eclipse.tracecompass.internal.provisional.segmentstore.core.BasicSegment2; import org.eclipse.tracecompass.internal.segmentstore.core.segmentHistoryTree.SegmentTreeNode; +import org.eclipse.tracecompass.segmentstore.core.BasicSegment; import org.eclipse.tracecompass.segmentstore.core.tests.historytree.SegmentTreeNodeStub; import org.junit.Test; import org.junit.runner.RunWith; @@ -40,12 +40,12 @@ import com.google.common.collect.ImmutableSet; */ @NonNullByDefault @RunWith(Parameterized.class) -public class SegmentTreeCoreNodeTest extends HTCoreNodeTest { +public class SegmentTreeCoreNodeTest extends HTCoreNodeTest { /** * A factory to create base objects for test */ - private static final ObjectFactory BASE_SEGMENT_FACTORY = (s, e) -> new BasicSegment2(s, e); + private static final ObjectFactory BASE_SEGMENT_FACTORY = (s, e) -> new BasicSegment(s, e); /** * Constructor @@ -65,9 +65,9 @@ public class SegmentTreeCoreNodeTest extends HTCoreNodeTest factory, - IHTIntervalReader objReader, - ObjectFactory objFactory) throws IOException { + IHTNodeFactory factory, + IHTIntervalReader objReader, + ObjectFactory objFactory) throws IOException { super(name, headerSize, factory, objReader, objFactory); } @@ -80,7 +80,7 @@ public class SegmentTreeCoreNodeTest extends HTCoreNodeTest { +public class SegmentTreeNodeTest extends HTNodeTest { /** * A factory to create base objects for test */ - private static final ObjectFactory BASE_SEGMENT_FACTORY = (s, e) -> new BasicSegment2(s, e); + private static final ObjectFactory BASE_SEGMENT_FACTORY = (s, e) -> new BasicSegment(s, e); /** * Constructor @@ -56,9 +56,9 @@ public class SegmentTreeNodeTest extends HTNodeTest factory, - IHTIntervalReader objReader, - ObjectFactory objFactory) throws IOException { + IHTNodeFactory factory, + IHTIntervalReader objReader, + ObjectFactory objFactory) throws IOException { super(name, headerSize, factory, objReader, objFactory); } @@ -71,7 +71,7 @@ public class SegmentTreeNodeTest extends HTNodeTest * The type of segments accepted in this store */ -public class HistoryTreeSegmentStoreStub extends HistoryTreeSegmentStore { +public class HistoryTreeSegmentStoreStub extends HistoryTreeSegmentStore { /** * Constructor for new history files. Use this when creating a new history diff --git a/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/stubs/org/eclipse/tracecompass/segmentstore/core/tests/historytree/SegmentHistoryTreeStub.java b/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/stubs/org/eclipse/tracecompass/segmentstore/core/tests/historytree/SegmentHistoryTreeStub.java index 03fe45ed68..96b7679336 100644 --- a/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/stubs/org/eclipse/tracecompass/segmentstore/core/tests/historytree/SegmentHistoryTreeStub.java +++ b/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/stubs/org/eclipse/tracecompass/segmentstore/core/tests/historytree/SegmentHistoryTreeStub.java @@ -14,9 +14,9 @@ import java.io.IOException; import org.eclipse.tracecompass.datastore.core.interval.IHTIntervalReader; import org.eclipse.tracecompass.internal.provisional.datastore.core.historytree.IHistoryTree; -import org.eclipse.tracecompass.internal.provisional.segmentstore.core.ISegment2; import org.eclipse.tracecompass.internal.segmentstore.core.segmentHistoryTree.SegmentHistoryTree; import org.eclipse.tracecompass.internal.segmentstore.core.segmentHistoryTree.SegmentTreeNode; +import org.eclipse.tracecompass.segmentstore.core.ISegment; /** * A stub segment history tree that extends the base segment history tree and @@ -26,7 +26,7 @@ import org.eclipse.tracecompass.internal.segmentstore.core.segmentHistoryTree.Se * @param * The type of segments that goes in this tree */ -public class SegmentHistoryTreeStub extends SegmentHistoryTree { +public class SegmentHistoryTreeStub extends SegmentHistoryTree { private int fLastInsertionIndex; diff --git a/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/stubs/org/eclipse/tracecompass/segmentstore/core/tests/historytree/SegmentTreeNodeStub.java b/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/stubs/org/eclipse/tracecompass/segmentstore/core/tests/historytree/SegmentTreeNodeStub.java index df0c9abaec..27a8265c6f 100644 --- a/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/stubs/org/eclipse/tracecompass/segmentstore/core/tests/historytree/SegmentTreeNodeStub.java +++ b/statesystem/org.eclipse.tracecompass.segmentstore.core.tests/stubs/org/eclipse/tracecompass/segmentstore/core/tests/historytree/SegmentTreeNodeStub.java @@ -10,8 +10,8 @@ package org.eclipse.tracecompass.segmentstore.core.tests.historytree; import org.eclipse.tracecompass.internal.provisional.datastore.core.historytree.AbstractHistoryTree.IHTNodeFactory; -import org.eclipse.tracecompass.internal.provisional.segmentstore.core.BasicSegment2; import org.eclipse.tracecompass.internal.segmentstore.core.segmentHistoryTree.SegmentTreeNode; +import org.eclipse.tracecompass.segmentstore.core.BasicSegment; /** * A stub segment tree node to expose some functionalities of the segment tree @@ -19,10 +19,10 @@ import org.eclipse.tracecompass.internal.segmentstore.core.segmentHistoryTree.Se * * @author Geneviève Bastien */ -public class SegmentTreeNodeStub extends SegmentTreeNode { +public class SegmentTreeNodeStub extends SegmentTreeNode { /** Factory to create nodes of this type */ - public static final IHTNodeFactory NODE_FACTORY = + public static final IHTNodeFactory NODE_FACTORY = (t, b, m, seq, p, start) -> new SegmentTreeNodeStub(t, b, m, seq, p, start); /** diff --git a/statesystem/org.eclipse.tracecompass.segmentstore.core/META-INF/MANIFEST.MF b/statesystem/org.eclipse.tracecompass.segmentstore.core/META-INF/MANIFEST.MF index 0553e1868a..10fb9d000f 100644 --- a/statesystem/org.eclipse.tracecompass.segmentstore.core/META-INF/MANIFEST.MF +++ b/statesystem/org.eclipse.tracecompass.segmentstore.core/META-INF/MANIFEST.MF @@ -12,8 +12,7 @@ Require-Bundle: org.eclipse.core.runtime, org.eclipse.core.resources, org.eclipse.tracecompass.common.core, org.eclipse.tracecompass.datastore.core -Export-Package: org.eclipse.tracecompass.internal.provisional.segmentstore.core;x-friends:="org.eclipse.tracecompass.segmentstore.core.tests", - org.eclipse.tracecompass.internal.segmentstore.core;x-internal:=true, +Export-Package: org.eclipse.tracecompass.internal.segmentstore.core;x-internal:=true, org.eclipse.tracecompass.internal.segmentstore.core.arraylist;x-friends:="org.eclipse.tracecompass.segmentstore.core.tests", org.eclipse.tracecompass.internal.segmentstore.core.segmentHistoryTree;x-friends:="org.eclipse.tracecompass.segmentstore.core.tests", org.eclipse.tracecompass.internal.segmentstore.core.treemap;x-friends:="org.eclipse.tracecompass.segmentstore.core.tests", diff --git a/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/provisional/segmentstore/core/BasicSegment2.java b/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/provisional/segmentstore/core/BasicSegment2.java deleted file mode 100644 index ccaaca10ef..0000000000 --- a/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/provisional/segmentstore/core/BasicSegment2.java +++ /dev/null @@ -1,47 +0,0 @@ -/******************************************************************************* - * 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 - *******************************************************************************/ - -package org.eclipse.tracecompass.internal.provisional.segmentstore.core; - -import org.eclipse.tracecompass.datastore.core.interval.HTInterval; -import org.eclipse.tracecompass.datastore.core.interval.IHTIntervalReader; - -/** - * Extension of the BasicSegment, to implement ISegment2 so that it can be - * stored in a history tree backend. - * - * @since 1.2 - */ -public class BasicSegment2 extends HTInterval implements ISegment2 { - - /** - * The factory to read an object from a buffer - */ - public static final IHTIntervalReader BASIC_SEGMENT_READ_FACTORY = buffer -> { - return new BasicSegment2(buffer.getLong(), buffer.getLong()); - }; - - /** - * Constructor - * - * @param start - * start of the segment - * @param end - * end of the segment - */ - public BasicSegment2(long start, long end) { - super(start, end); - } - - /** - * - */ - private static final long serialVersionUID = -3083730702354275357L; - -} diff --git a/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/provisional/segmentstore/core/ISegment2.java b/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/provisional/segmentstore/core/ISegment2.java deleted file mode 100644 index 57af19651d..0000000000 --- a/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/provisional/segmentstore/core/ISegment2.java +++ /dev/null @@ -1,28 +0,0 @@ -/******************************************************************************* - * 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 - *******************************************************************************/ - -package org.eclipse.tracecompass.internal.provisional.segmentstore.core; - -import org.eclipse.tracecompass.datastore.core.interval.IHTInterval; -import org.eclipse.tracecompass.segmentstore.core.ISegment; - -/** - * This is a segment that can be saved in a history tree backend - * - * Note: It should be ISegment, but that would be API breaking, so this - * interface was added so a segment can be both segment and history tree object. - * - * FIXME: Move that to ISegment when breaking the API - * - * @author Geneviève Bastien - * @since 1.2 - */ -public interface ISegment2 extends ISegment, IHTInterval { - -} diff --git a/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/provisional/segmentstore/core/package-info.java b/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/provisional/segmentstore/core/package-info.java deleted file mode 100644 index 79f786c5a8..0000000000 --- a/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/provisional/segmentstore/core/package-info.java +++ /dev/null @@ -1,11 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2017 É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.internal.provisional.segmentstore.core; diff --git a/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/segmentstore/core/segmentHistoryTree/HistoryTreeSegmentStore.java b/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/segmentstore/core/segmentHistoryTree/HistoryTreeSegmentStore.java index b523644db8..428f23238b 100644 --- a/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/segmentstore/core/segmentHistoryTree/HistoryTreeSegmentStore.java +++ b/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/segmentstore/core/segmentHistoryTree/HistoryTreeSegmentStore.java @@ -21,7 +21,6 @@ import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; import org.eclipse.tracecompass.common.core.NonNullUtils; import org.eclipse.tracecompass.datastore.core.interval.IHTIntervalReader; -import org.eclipse.tracecompass.internal.provisional.segmentstore.core.ISegment2; import org.eclipse.tracecompass.segmentstore.core.ISegment; import org.eclipse.tracecompass.segmentstore.core.ISegmentStore; @@ -39,9 +38,9 @@ import com.google.common.collect.Iterables; * @author Loic Prieur-Drevon * @author Geneviève Bastien * @param - * type of {@link ISegment2} + * type of {@link ISegment} */ -public class HistoryTreeSegmentStore implements ISegmentStore { +public class HistoryTreeSegmentStore implements ISegmentStore { private static final int PROVIDER_VERSION = 1; // TODO: these values were taken from the state system implementation. Maybe diff --git a/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/segmentstore/core/segmentHistoryTree/SegmentHistoryTree.java b/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/segmentstore/core/segmentHistoryTree/SegmentHistoryTree.java index 9729f64f78..41e32375ce 100644 --- a/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/segmentstore/core/segmentHistoryTree/SegmentHistoryTree.java +++ b/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/segmentstore/core/segmentHistoryTree/SegmentHistoryTree.java @@ -28,7 +28,6 @@ import org.eclipse.tracecompass.internal.provisional.datastore.core.condition.Ti import org.eclipse.tracecompass.internal.provisional.datastore.core.historytree.HTNode; import org.eclipse.tracecompass.internal.provisional.datastore.core.historytree.IHTNode; import org.eclipse.tracecompass.internal.provisional.datastore.core.historytree.overlapping.AbstractOverlappingHistoryTree; -import org.eclipse.tracecompass.internal.provisional.segmentstore.core.ISegment2; import org.eclipse.tracecompass.internal.segmentstore.core.Activator; import org.eclipse.tracecompass.segmentstore.core.BasicSegment; import org.eclipse.tracecompass.segmentstore.core.ISegment; @@ -44,7 +43,7 @@ import com.google.common.annotations.VisibleForTesting; * @param * type of {@link ISegment} */ -public class SegmentHistoryTree extends AbstractOverlappingHistoryTree> { +public class SegmentHistoryTree extends AbstractOverlappingHistoryTree> { private static final int HISTORY_MAGIC_NUMBER = 0x05FFC600; diff --git a/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/segmentstore/core/segmentHistoryTree/SegmentTreeNode.java b/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/segmentstore/core/segmentHistoryTree/SegmentTreeNode.java index 8d01d72702..9c3e80e209 100644 --- a/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/segmentstore/core/segmentHistoryTree/SegmentTreeNode.java +++ b/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/internal/segmentstore/core/segmentHistoryTree/SegmentTreeNode.java @@ -21,8 +21,8 @@ import org.eclipse.jdt.annotation.Nullable; import org.eclipse.tracecompass.internal.provisional.datastore.core.condition.TimeRangeCondition; import org.eclipse.tracecompass.internal.provisional.datastore.core.historytree.IHTNode; import org.eclipse.tracecompass.internal.provisional.datastore.core.historytree.overlapping.OverlappingNode; -import org.eclipse.tracecompass.internal.provisional.segmentstore.core.BasicSegment2; -import org.eclipse.tracecompass.internal.provisional.segmentstore.core.ISegment2; +import org.eclipse.tracecompass.segmentstore.core.BasicSegment; +import org.eclipse.tracecompass.segmentstore.core.ISegment; import org.eclipse.tracecompass.segmentstore.core.SegmentComparators; /** @@ -34,9 +34,9 @@ import org.eclipse.tracecompass.segmentstore.core.SegmentComparators; * @author Loic Prieur-Drevon * @author Geneviève Bastien * @param - * type of {@link ISegment2} + * type of {@link ISegment} */ -public class SegmentTreeNode extends OverlappingNode { +public class SegmentTreeNode extends OverlappingNode { // These values represent the values for the current node only, not its // children @@ -70,9 +70,9 @@ public class SegmentTreeNode extends OverlappingNode { * Adds the data concerning the segment nodes, max start/min end and * durations * - * @param type of {@link ISegment2} + * @param type of {@link ISegment} */ - protected static class OverlappingSegmentCoreData extends OverlappingExtraData { + protected static class OverlappingSegmentCoreData extends OverlappingExtraData { // These values cover the full subtrees of the child nodes // Max start of an interval @@ -305,22 +305,22 @@ public class SegmentTreeNode extends OverlappingNode { * @return A segment whose value for the field that correspond to the * comparator is the least value of the child node */ - public ISegment2 getIndex(int index, Comparator order) { + public ISegment getIndex(int index, Comparator order) { if (order.equals(SegmentComparators.INTERVAL_START_COMPARATOR)) { - return new BasicSegment2(getChildStart(index), getChildStart(index)); + return new BasicSegment(getChildStart(index), getChildStart(index)); } else if (order.equals(SegmentComparators.INTERVAL_START_COMPARATOR.reversed())) { - return new BasicSegment2(fChildMaxStart[index], fChildMaxStart[index]); + return new BasicSegment(fChildMaxStart[index], fChildMaxStart[index]); } else if (order.equals(SegmentComparators.INTERVAL_END_COMPARATOR)) { - return new BasicSegment2(fChildMinEnd[index], fChildMinEnd[index]); + return new BasicSegment(fChildMinEnd[index], fChildMinEnd[index]); } else if (order.equals(SegmentComparators.INTERVAL_END_COMPARATOR.reversed())) { - return new BasicSegment2(getChildEnd(index), getChildEnd(index)); + return new BasicSegment(getChildEnd(index), getChildEnd(index)); } else if (order.equals(SegmentComparators.INTERVAL_LENGTH_COMPARATOR)) { - return new BasicSegment2(0, fMinLength[index]); + return new BasicSegment(0, fMinLength[index]); } else if (order.equals(SegmentComparators.INTERVAL_LENGTH_COMPARATOR.reversed())) { - return new BasicSegment2(0, fMaxLength[index]); + return new BasicSegment(0, fMaxLength[index]); } // TODO: Don't know what to do with other comparators yet - return new BasicSegment2(getChild(index), getChild(index)); + return new BasicSegment(getChild(index), getChild(index)); } } @@ -395,10 +395,10 @@ public class SegmentTreeNode extends OverlappingNode { * @return For each intersecting child, a Tuple with the segment with the * least value for the comparator */ - public Set> selectNextChildren(TimeRangeCondition range, Comparator order) { + public Set> selectNextChildren(TimeRangeCondition range, Comparator order) { OverlappingSegmentCoreData extraData = getCoreNodeData(); if (extraData != null) { - Set> set = new HashSet<>(); + Set> set = new HashSet<>(); for (Integer index : extraData.selectNextIndices(range)) { set.add(new Tuple<>(extraData.getIndex(index, order), extraData.getChild(index))); } diff --git a/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/segmentstore/core/BasicSegment.java b/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/segmentstore/core/BasicSegment.java index b1e6869043..9ddc85c705 100644 --- a/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/segmentstore/core/BasicSegment.java +++ b/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/segmentstore/core/BasicSegment.java @@ -9,6 +9,10 @@ package org.eclipse.tracecompass.segmentstore.core; +import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.tracecompass.datastore.core.interval.IHTIntervalReader; +import org.eclipse.tracecompass.datastore.core.serialization.ISafeByteBufferWriter; + /** * Basic implementation of {@link ISegment}. * @@ -16,6 +20,14 @@ package org.eclipse.tracecompass.segmentstore.core; */ public class BasicSegment implements ISegment { + /** + * The factory to read an object from a buffer + * @since 2.0 + */ + public static final IHTIntervalReader BASIC_SEGMENT_READ_FACTORY = buffer -> { + return new BasicSegment(buffer.getLong(), buffer.getLong()); + }; + private static final long serialVersionUID = -3257452887960883177L; private final long fStart; @@ -49,8 +61,27 @@ public class BasicSegment implements ISegment { return fEnd; } + /** + * @since 2.0 + */ + @Override + public int getSizeOnDisk() { + // Save the start and end time + return Long.BYTES * 2; + } + + /** + * @since 2.0 + */ + @Override + public void writeSegment(@NonNull ISafeByteBufferWriter buffer) { + buffer.putLong(getStart()); + buffer.putLong(getEnd()); + } + @Override public String toString() { return new String('[' + String.valueOf(fStart) + ", " + String.valueOf(fEnd) + ']'); //$NON-NLS-1$ } + } diff --git a/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/segmentstore/core/ISegment.java b/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/segmentstore/core/ISegment.java index eff096573a..60a80eda9f 100644 --- a/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/segmentstore/core/ISegment.java +++ b/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/segmentstore/core/ISegment.java @@ -15,6 +15,8 @@ package org.eclipse.tracecompass.segmentstore.core; import java.io.Serializable; import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.tracecompass.datastore.core.interval.IHTInterval; +import org.eclipse.tracecompass.datastore.core.serialization.ISafeByteBufferWriter; /** * Generic interface for any segment (like a time range) that can be used in the @@ -22,21 +24,7 @@ import org.eclipse.jdt.annotation.NonNull; * * @author Alexandre Montplaisir */ -public interface ISegment extends Serializable, Comparable<@NonNull ISegment> { - - /** - * The start position/time of the segment. - * - * @return The start position - */ - long getStart(); - - /** - * The end position/time of the segment - * - * @return The end position - */ - long getEnd(); +public interface ISegment extends Serializable, Comparable<@NonNull ISegment>, IHTInterval { @Override default int compareTo(@NonNull ISegment arg0) { @@ -53,4 +41,21 @@ public interface ISegment extends Serializable, Comparable<@NonNull ISegment> { default long getLength() { return getEnd() - getStart(); } + + /** + * @since 2.0 + */ + @Override + default int getSizeOnDisk() { + return 0; + } + + /** + * @since 2.0 + */ + @Override + default void writeSegment(@NonNull ISafeByteBufferWriter buffer) { + + } + } diff --git a/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/segmentstore/core/SegmentStoreFactory.java b/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/segmentstore/core/SegmentStoreFactory.java index 0c7bd2fb87..5a2d1ea7fe 100644 --- a/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/segmentstore/core/SegmentStoreFactory.java +++ b/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/segmentstore/core/SegmentStoreFactory.java @@ -20,7 +20,6 @@ import java.util.Set; import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; import org.eclipse.tracecompass.datastore.core.interval.IHTIntervalReader; -import org.eclipse.tracecompass.internal.provisional.segmentstore.core.ISegment2; import org.eclipse.tracecompass.internal.segmentstore.core.arraylist.ArrayListStore; import org.eclipse.tracecompass.internal.segmentstore.core.arraylist.LazyArrayListStore; import org.eclipse.tracecompass.internal.segmentstore.core.segmentHistoryTree.HistoryTreeSegmentStore; @@ -131,7 +130,7 @@ public final class SegmentStoreFactory { * Exceptions when creating the segment store * @since 2.0 */ - public static ISegmentStore createOnDiskSegmentStore(Path segmentFile, IHTIntervalReader segmentReader) throws IOException { + public static ISegmentStore createOnDiskSegmentStore(Path segmentFile, IHTIntervalReader segmentReader) throws IOException { return new HistoryTreeSegmentStore<>(segmentFile, segmentReader); } diff --git a/tmf/org.eclipse.tracecompass.tmf.analysis.xml.core/META-INF/MANIFEST.MF b/tmf/org.eclipse.tracecompass.tmf.analysis.xml.core/META-INF/MANIFEST.MF index 45cdf42516..eee55f403f 100644 --- a/tmf/org.eclipse.tracecompass.tmf.analysis.xml.core/META-INF/MANIFEST.MF +++ b/tmf/org.eclipse.tracecompass.tmf.analysis.xml.core/META-INF/MANIFEST.MF @@ -11,6 +11,7 @@ Bundle-ActivationPolicy: lazy Require-Bundle: org.eclipse.core.runtime, org.eclipse.tracecompass.common.core, org.eclipse.tracecompass.tmf.core, + org.eclipse.tracecompass.datastore.core, org.eclipse.tracecompass.segmentstore.core, org.eclipse.tracecompass.analysis.timing.core Export-Package: org.eclipse.tracecompass.internal.tmf.analysis.xml.core;x-friends:="org.eclipse.tracecompass.tmf.analysis.xml.core.tests",