diff --git a/plugins/com.minres.scviewer.database/src/com/minres/scviewer/database/EventList.java b/plugins/com.minres.scviewer.database/src/com/minres/scviewer/database/EventList.java index c5a7fea..d5db634 100644 --- a/plugins/com.minres.scviewer.database/src/com/minres/scviewer/database/EventList.java +++ b/plugins/com.minres.scviewer.database/src/com/minres/scviewer/database/EventList.java @@ -3,193 +3,112 @@ package com.minres.scviewer.database; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; +import java.util.NoSuchElementException; -public class EventList implements IEventList { +/** Sorted timestamp buckets. Range views are read-only and bounded by their parent. */ +public class EventList implements IEventList { + private final ArrayList store; + private final int start; + private int end; + private final boolean unmodifiable; - ArrayList store = new ArrayList<>(); - int start = 0; - int end = store.size(); - boolean unmodifiable = false; - - public class Iterator implements java.util.Iterator { - - EventList list; - - private int pos; - - public Iterator(EventList list) { - this.list=list; - this.pos=-1; - } + public EventList() { + this(new ArrayList<>(), 0, 0, false); + } - @Override - public boolean hasNext() { - return pos<(list.end-1); - } + private EventList(ArrayList store, int start, int end, boolean unmodifiable) { + this.store = store; + this.start = start; + this.end = end; + this.unmodifiable = unmodifiable; + } - @Override - public EventEntry next() { - if(hasNext()) { - pos++; - return list.store.get(pos); - } else - return null; - } - - @Override - public void remove() { - list.store.remove(pos); - } - - } - - public EventList() { - } - - private EventList(ArrayList store , int start, int end) { - this.store=store; - this.start=start; - this.end=end; - this.unmodifiable=true; - } - - @Override - public IEventList subMap(long from, boolean includeFrom, long to) { - //the index of the first element greater than the key, or list.size() - int beginIndex = Collections.binarySearch(store, new EventEntry(from)); - int startIndex = beginIndex < 0? -(beginIndex + 1): beginIndex; - int endIndex = Collections.binarySearch(store, new EventEntry(to)); - endIndex = endIndex < 0? -(endIndex + 1): endIndex+1; - if(beginIndex>0 && !includeFrom) - return new EventList(store, startIndex+1, endIndex); - else - return new EventList(store, startIndex, endIndex); - } - - @Override - public int size() { - return end-start; - } - - @Override - public boolean containsKey(long key) { - int index = Collections.binarySearch(store, new EventEntry(key)); - return index>=0 && index>=start && index=start && index entrySet() { - if(start != 0 || end != store.size()) - return Collections.unmodifiableList(store.subList(start, end)); - else - return Collections.unmodifiableList(store); - } - - @Override - public boolean isEmpty() { - return start==end || store.isEmpty(); - } - - @Override - public long firstKey() { - return store.get(start).timestamp; - } - - @Override - public long lastKey() { - return store.get(end-1).timestamp; - } - - // Navigable map functions - @Override - public EventEntry firstEntry() { - return store.get(start); - } - - @Override - public EventEntry lastEntry() { - return store.get(end-1); - } - - @Override - public EventEntry floorEntry(long key) { - int index = Collections.binarySearch(store, new EventEntry(key)); - if(index==-1) return null; - // < 0 if element is not in the list, see Collections.binarySearch - if (index < 0) { - index = -(index + 2); + /** Index of the first timestamp >= key (or > key when exclusive). */ + private int bound(long key, boolean exclusive) { + int low = start, high = end; + while (low < high) { + int mid = (low + high) >>> 1; + int cmp = Long.compareUnsigned(store.get(mid).timestamp, key); + if (cmp < 0 || (exclusive && cmp == 0)) low = mid + 1; + else high = mid; } - if(index>=end) - return store.get(end-1); - return index=end? null: store.get(index); - } + private EventEntry entry(int index) { + return index < start || index >= end ? null : store.get(index); + } - @Override - public EventEntry lowerEntry(long key) { - int index = Collections.binarySearch(store, new EventEntry(key)); - // < 0 if element is not in the list, see Collections.binarySearch - if (index < 0) - index = -(index + 1); - index--; - if(index>=end) - return store.get(end-1); - return index>=end || index 0) throw new IllegalArgumentException("Reversed time range"); + int first = bound(from, !includeFrom); + return new EventList(store, first, Math.max(first, bound(to, true)), true); + } - @Override - public EventEntry higherEntry(long key) { - int index = Collections.binarySearch(store, new EventEntry(key)); - // < 0 if element is not in the list, see Collections.binarySearch - if (index < 0) - index = -(index + 1); - else - index++; - if(index=end || index iterator() { - return new Iterator(this); - } + @Override + public boolean containsKey(long key) { + EventEntry e = entry(bound(key, false)); + return e != null && e.timestamp == key; + } + @Override + public IEvent[] get(long key) { + EventEntry e = entry(bound(key, false)); + return e != null && e.timestamp == key ? e.events : null; + } + + @Override + public void put(long key, IEvent value) { + if (unmodifiable) throw new UnsupportedOperationException(); + int index = store.isEmpty() || Long.compareUnsigned(store.get(end - 1).timestamp, key) < 0 + ? end : bound(key, false); + if (index < end && store.get(index).timestamp == key) store.get(index).append(value); + else store.add(index, new EventEntry(key, new IEvent[] {value})); + end = store.size(); + } + + @Override + public Collection entrySet() { + return Collections.unmodifiableList(store.subList(start, end)); + } + + @Override + public boolean isEmpty() { return start == end; } + + @Override + public long firstKey() { + if (isEmpty()) throw new NoSuchElementException(); + return store.get(start).timestamp; + } + + @Override + public long lastKey() { + if (isEmpty()) throw new NoSuchElementException(); + return store.get(end - 1).timestamp; + } + + @Override + public EventEntry firstEntry() { return entry(start); } + + @Override + public EventEntry lastEntry() { return entry(end - 1); } + + @Override + public EventEntry floorEntry(long key) { return entry(bound(key, true) - 1); } + + @Override + public EventEntry ceilingEntry(long key) { return entry(bound(key, false)); } + + @Override + public EventEntry lowerEntry(long key) { return entry(bound(key, false) - 1); } + + @Override + public EventEntry higherEntry(long key) { return entry(bound(key, true)); } + + @Override + public java.util.Iterator iterator() { return entrySet().iterator(); } } diff --git a/tests/com.minres.scviewer.database.test/src/com/minres/scviewer/database/test/EventListTest.java b/tests/com.minres.scviewer.database.test/src/com/minres/scviewer/database/test/EventListTest.java index 21db15f..88a6223 100644 --- a/tests/com.minres.scviewer.database.test/src/com/minres/scviewer/database/test/EventListTest.java +++ b/tests/com.minres.scviewer.database.test/src/com/minres/scviewer/database/test/EventListTest.java @@ -194,4 +194,39 @@ public class EventListTest { assertNotNull(populatedList.get(5)); assertNull(populatedList.get(7)); } + + @Test + public void testRangeIterationAndBounds() { + IEventList list = createList(new int[] {2, 5, 8, 11}); + IEventList view = list.subMap(5, true, 8); + java.util.List times = new java.util.ArrayList<>(); + for (com.minres.scviewer.database.EventEntry e : view) times.add(e.timestamp); + assertArrayEquals(new Long[] {5L, 8L}, times.toArray(new Long[0])); + assertArrayEquals(new Long[] {5L}, getTimestamps(list.subMap(2, false, 5))); + assertArrayEquals(new Long[] {5L, 8L}, getTimestamps(view.subMap(2, true, 11))); + assertTrue(list.subMap(2, false, 2).isEmpty()); + java.util.Iterator iterator = view.iterator(); + iterator.next(); + try { iterator.remove(); org.junit.Assert.fail("Read-only iterator"); } + catch (UnsupportedOperationException expected) { } + assertEquals(4, list.size()); + } + + @Test + public void testEmptyNavigationAndUnsignedOrder() { + IEventList empty = new EventList(); + assertNull(empty.firstEntry()); + assertNull(empty.lastEntry()); + assertNull(empty.floorEntry(5)); + assertNull(empty.ceilingEntry(5)); + assertNull(empty.lowerEntry(5)); + assertNull(empty.higherEntry(5)); + EventList list = new EventList(); + list.put(Long.MIN_VALUE, null); + list.put(Long.MAX_VALUE, null); + assertEquals(Long.MAX_VALUE, list.firstKey()); + assertNotNull(list.get(Long.MIN_VALUE)); + assertNotNull(list.get(Long.MAX_VALUE)); + assertNull(list.subMap(0, true, 1).floorEntry(20)); + } }