X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=statesystem%2Forg.eclipse.tracecompass.segmentstore.core%2Fsrc%2Forg%2Feclipse%2Ftracecompass%2Fsegmentstore%2Fcore%2Ftreemap%2FTreeMapStore.java;h=e8014ad2928779acf18692fc4500f37fde0237d1;hb=50b08ea88a4ca3d4ffcb52333a4e0ed688dbbdb5;hp=e0acbab718ea0af6c26ed323dce6f43d7e2b32e9;hpb=71e78f69aa555b47dbffa42b55809b30dc27233d;p=deliverable%2Ftracecompass.git diff --git a/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/segmentstore/core/treemap/TreeMapStore.java b/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/segmentstore/core/treemap/TreeMapStore.java index e0acbab718..e8014ad292 100644 --- a/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/segmentstore/core/treemap/TreeMapStore.java +++ b/statesystem/org.eclipse.tracecompass.segmentstore.core/src/org/eclipse/tracecompass/segmentstore/core/treemap/TreeMapStore.java @@ -12,21 +12,15 @@ package org.eclipse.tracecompass.segmentstore.core.treemap; -import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; - +import java.util.Collection; import java.util.Iterator; import java.util.TreeMap; -import java.util.concurrent.locks.ReadWriteLock; -import java.util.concurrent.locks.ReentrantReadWriteLock; +import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.jdt.annotation.Nullable; import org.eclipse.tracecompass.segmentstore.core.ISegment; import org.eclipse.tracecompass.segmentstore.core.ISegmentStore; -import org.eclipse.tracecompass.segmentstore.core.SegmentComparators; - -import com.google.common.collect.Iterables; -import com.google.common.collect.Ordering; -import com.google.common.collect.Sets; -import com.google.common.collect.TreeMultimap; +import org.eclipse.tracecompass.segmentstore.core.SegmentStoreFactory; /** * Implementation of a {@link ISegmentStore} using in-memory {@link TreeMap}'s. @@ -42,116 +36,109 @@ import com.google.common.collect.TreeMultimap; * that if you want several segments with the same start and end times, make * sure their compareTo() differentiates them. * - * @param + * Removal operations are not supported. + * + * @param * The type of segment held in this store * * @author Alexandre Montplaisir + * @deprecated Use the {@link SegmentStoreFactory} to create a new segment store */ -public class TreeMapStore implements ISegmentStore { - - private final ReadWriteLock fLock = new ReentrantReadWriteLock(false); - - private final TreeMultimap fStartTimesIndex; - private final TreeMultimap fEndTimesIndex; - - private long fSize; +@Deprecated +public class TreeMapStore<@NonNull E extends ISegment> extends org.eclipse.tracecompass.internal.segmentstore.core.treemap.TreeMapStore { /** * Constructor */ public TreeMapStore() { - /* - * For the start times index, the "key comparator" will compare the - * start times as longs directly. This is the primary comparator for its - * tree map. - * - * The secondary "value" comparator will check the end times first, and - * in the event of a tie, defer to the ISegment's Comparable - * implementation, a.k.a. its natural ordering. - * - * The same is done for the end times index, but swapping the first two - * comparators instead. - */ - fStartTimesIndex = checkNotNull(TreeMultimap. create( - SegmentComparators.LONG_COMPARATOR, - Ordering.from(SegmentComparators.INTERVAL_END_COMPARATOR).compound(Ordering.natural()))); - - fEndTimesIndex = checkNotNull(TreeMultimap. create( - SegmentComparators.LONG_COMPARATOR, - Ordering.from(SegmentComparators.INTERVAL_START_COMPARATOR).compound(Ordering.natural()))); - - fSize = 0; + super(); + } + + // ------------------------------------------------------------------------ + // Methods from Collection + // ------------------------------------------------------------------------ + + @Override + public Iterator iterator() { + return super.iterator(); + } + + @Override + public boolean add(@Nullable E val) { + return super.add(val); + } + + @Override + public int size() { + return super.size(); // me + } + + @Override + public boolean isEmpty() { + return super.isEmpty(); + } + + @Override + public boolean contains(@Nullable Object o) { + return super.contains(o); + } + + @Override + public boolean containsAll(@Nullable Collection c) { + return super.containsAll(c); + } + + @Override + public Object[] toArray() { + return super.toArray(); } - /** - * Warning, this is not thread safe, and can cause concurrent modification - * exceptions - */ @Override - public Iterator iterator() { - return checkNotNull(fStartTimesIndex.values().iterator()); + public T[] toArray(T[] a) { + return super.toArray(a); } @Override - public void addElement(T val) { - fLock.writeLock().lock(); - try { - if (fStartTimesIndex.put(Long.valueOf(val.getStart()), val)) { - fEndTimesIndex.put(Long.valueOf(val.getEnd()), val); - fSize++; - } - } finally { - fLock.writeLock().unlock(); - } + public boolean remove(@Nullable Object o) { + return super.remove(o); } @Override - public long getNbElements() { - fLock.readLock().lock(); - try { - return fSize; - } finally { - fLock.readLock().unlock(); - } + public boolean addAll(@Nullable Collection c) { + return super.addAll(c); } @Override - public Iterable getIntersectingElements(long position) { - /* - * The intervals intersecting 't' are those whose 1) start time is - * *lower* than 't' AND 2) end time is *higher* than 't'. - */ - fLock.readLock().lock(); - try { - Iterable matchStarts = Iterables.concat(fStartTimesIndex.asMap().headMap(position, true).values()); - Iterable matchEnds = Iterables.concat(fEndTimesIndex.asMap().tailMap(position, true).values()); - return checkNotNull(Sets.intersection(Sets.newHashSet(matchStarts), Sets.newHashSet(matchEnds))); - } finally { - fLock.readLock().unlock(); - } + public boolean removeAll(@Nullable Collection c) { + return super.removeAll(c); + } + + @Override + public boolean retainAll(@Nullable Collection c) { + return super.retainAll(c); + } + + @Override + public void clear() { + super.clear(); + } + + // ------------------------------------------------------------------------ + // Methods added by ISegmentStore + // ------------------------------------------------------------------------ + + @Override + public Iterable getIntersectingElements(long position) { + return super.getIntersectingElements(position); } @Override - public Iterable getIntersectingElements(long start, long end) { - fLock.readLock().lock(); - try { - Iterable matchStarts = Iterables.concat(fStartTimesIndex.asMap().headMap(end, true).values()); - Iterable matchEnds = Iterables.concat(fEndTimesIndex.asMap().tailMap(start, true).values()); - return checkNotNull(Sets.intersection(Sets.newHashSet(matchStarts), Sets.newHashSet(matchEnds))); - } finally { - fLock.readLock().unlock(); - } + public Iterable getIntersectingElements(long start, long end) { + return super.getIntersectingElements(start, end); } @Override public void dispose() { - fLock.writeLock().lock(); - try { - fStartTimesIndex.clear(); - fEndTimesIndex.clear(); - fSize = 0; - } finally { - fLock.writeLock().unlock(); - } + super.dispose(); } }