Add a tested sliding window.

It provides a container that collects values with timestamps and
lets you access only the values in a certain "time window".

java/src/main/java/lp/java/understanding/SlidingWindow.java

@@ -0,0 +1,85 @@
package lp.java.understanding;
import java.util.ArrayList;
import java.util.List;
public class SlidingWindow<T> {
    private static final long NEVER = -1;
    private List<Long> currentTimestamps;
    private List<T> currentValues;
    private List<Long> newTimestamps;
    private List<T> newValues;
    private long windowStart;
    private long windowSize;
    public SlidingWindow(long windowSize) {
        currentTimestamps = new ArrayList<Long>();
        currentValues = new ArrayList<T>();
        newTimestamps = new ArrayList<Long>();
        newValues = new ArrayList<T>();
        windowStart = NEVER;
        this.windowSize = windowSize;
    }
    public List<T> getCurrentValues() {
        return currentValues;
    }
    public void addValue(T value, long timestamp) {
        if (windowStart == NEVER) {
            windowStart = timestamp;
        }
        if (isInWindow(timestamp)) {
            currentTimestamps.add(timestamp);
            currentValues.add(value);
        } else {
            newTimestamps.add(timestamp);
            newValues.add(value);
        }
    }
    public long getWindowStart() {
        return windowStart;
    }
    public boolean isInWindow(long timestamp) {
        return timestamp >= windowStart && timestamp < windowStart + windowSize;
    }
    public long getWindowSize() {
        return windowSize;
    }
    public long getWindowEnd() {
        return windowStart + windowSize;
    }
    public boolean canSlide() {
        return !newValues.isEmpty();
    }
    public void slide(long slideBy) {
        windowStart += slideBy;
        for (int i = 0; i < currentValues.size(); i++) {
            long timestamp = currentTimestamps.get(i);
            if (!isInWindow(timestamp)) {
                currentTimestamps.remove(i);
                currentValues.remove(i);
                i -= 1;
            }
        }
        for (int i = 0; i < newValues.size(); i++) {
            long timestamp = newTimestamps.get(i);
            if (isInWindow(timestamp)) {
                T value = newValues.get(i);
                currentTimestamps.add(timestamp);
                currentValues.add(value);
                newTimestamps.remove(i);
                newValues.remove(i);
                i -= 1;
            }
        }
    }
}

java/src/test/java/lp/java/understanding/TestSlidingWindow.java

@@ -0,0 +1,92 @@
package lp.java.understanding;
import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;
public class TestSlidingWindow {
    private SlidingWindow<Integer> window;
    @Before
    public void setUp() {
        window = new SlidingWindow<Integer>(10);
    }
    @Test
    public void initiallyTheSlidingWindowHoldsNoValues() {
        assertTrue(window.getCurrentValues().isEmpty());
    }
    @Test
    public void testIsInWindow() {
        window.addValue(0, 0);
        assertFalse("before window start", window.isInWindow(window.getWindowStart() - 1));
        assertTrue("at window start", window.isInWindow(window.getWindowStart()));
        assertTrue("after window start", window.isInWindow(window.getWindowStart() + 1));
        assertFalse("excluding window end", window.isInWindow(window.getWindowEnd()));
        assertFalse("after window end", window.isInWindow(window.getWindowEnd() + 10));
    }
    @Test
    public void addingAValueInTheCurrentWindowAddsItImmediately() {
        window.addValue(0, 0);
        window.addValue(1, window.getWindowStart());
        assertTrue(window.getCurrentValues().contains(1));
    }
    @Test
    public void addingAValueNotInTheCurrentWindowDoesntAddItImmediately() {
        window.addValue(0, 0);
        window.addValue(1, window.getWindowEnd());
        assertFalse(window.getCurrentValues().contains(1));
    }
    @Test
    public void theFirstAddedValueDeterminesTheWindowStart() {
        window.addValue(1, 42);
        assertEquals(42, window.getWindowStart());
    }
    @Test
    public void addingAValueOutsideOfTheCurrentWindowMakesItSlideable() {
        window.addValue(1, 0);
        assertFalse(window.canSlide());
        window.addValue(2, window.getWindowEnd());
        assertTrue(window.canSlide());
    }
    @Test
    public void slidingRemovesValuesNotInTheCurrentWindowAnymore() {
        addManyTimedValues(1, 0l, 2, 1l, 3, 5l, 4, 8l);
        assertWindowContains(1, 2, 3, 4);
        window.slide(2);
        assertWindowContains(3, 4);
    }
    private void addManyTimedValues(Object ...valuesWithTimestamps) {
        if (valuesWithTimestamps.length % 2 != 0) {
            throw new IllegalArgumentException("must pass even number of arguments");
        }
        for (int i = 0; i < valuesWithTimestamps.length; i += 2) {
            Integer value = (Integer) valuesWithTimestamps[i];
            Long timestamp = (Long) valuesWithTimestamps[i + 1];
            window.addValue(value, timestamp);
        }
    }
    @Test
    public void slidingAddsNewValuesFromTheNewWindow() {
        addManyTimedValues(1, 0l, 2, 1l, 3, 5l, 4, 8l, 5, 11l, 6, 20l);
        assertWindowContains(1, 2, 3, 4);
        window.slide(2);
        assertWindowContains(3, 4, 5);
        window.slide(10);
        assertWindowContains(6);
    }
    private void assertWindowContains(Integer ...values) {
        for (Integer value : values) {
            assertTrue("contains " + value, window.getCurrentValues().contains(value));
        }
    }
}