private void replaceRangeWithSameLowerBound(Range<C> range) { if (range.isEmpty()) { rangesByLowerBound.remove(range.lowerBound); } else { rangesByLowerBound.put(range.lowerBound, range); } }
/** * Add the specified range to this builder. Adjacent ranges are permitted and will be merged, * but overlapping ranges will cause an exception when {@link #build()} is called. * * @throws IllegalArgumentException if {@code range} is empty */ @CanIgnoreReturnValue public Builder<C> add(Range<C> range) { checkArgument(!range.isEmpty(), "range must not be empty, but was %s", range); ranges.add(range); return this; }
/** * Associates the specified range with the specified value. * * @throws IllegalArgumentException if {@code range} is empty */ @CanIgnoreReturnValue public Builder<K, V> put(Range<K> range, V value) { checkNotNull(range); checkNotNull(value); checkArgument(!range.isEmpty(), "Range must not be empty, but was %s", range); entries.add(Maps.immutableEntry(range, value)); return this; }
@Override public void put(Range<K> range, V value) { // don't short-circuit if the range is empty - it may be between two ranges we can coalesce. if (!range.isEmpty()) { checkNotNull(value); remove(range); entriesByLowerBound.put(range.lowerBound, new RangeMapEntry<K, V>(range, value)); } }
@Override public boolean intersects(Range<C> range) { checkNotNull(range); Entry<Cut<C>, Range<C>> ceilingEntry = rangesByLowerBound.ceilingEntry(range.lowerBound); if (ceilingEntry != null && ceilingEntry.getValue().isConnected(range) && !ceilingEntry.getValue().intersection(range).isEmpty()) { return true; } Entry<Cut<C>, Range<C>> priorEntry = rangesByLowerBound.lowerEntry(range.lowerBound); return priorEntry != null && priorEntry.getValue().isConnected(range) && !priorEntry.getValue().intersection(range).isEmpty(); }
/** * Returns an immutable range set containing the specified single range. If {@link Range#isEmpty() * range.isEmpty()}, this is equivalent to {@link ImmutableRangeSet#of()}. */ public static <C extends Comparable> ImmutableRangeSet<C> of(Range<C> range) { checkNotNull(range); if (range.isEmpty()) { return of(); } else if (range.equals(Range.all())) { return all(); } else { return new ImmutableRangeSet<C>(ImmutableList.of(range)); } }
public void testSpanSingleRange() { for (Range<Integer> range : RANGES) { RangeMap<Integer, Integer> rangeMap = TreeRangeMap.create(); rangeMap.put(range, 1); try { assertEquals(range, rangeMap.span()); assertFalse(range.isEmpty()); } catch (NoSuchElementException e) { assertTrue(range.isEmpty()); } } }
private void verify(Map<Integer, Integer> model, RangeMap<Integer, Integer> test) { for (int i = MIN_BOUND - 1; i <= MAX_BOUND + 1; i++) { assertEquals(model.get(i), test.get(i)); Entry<Range<Integer>, Integer> entry = test.getEntry(i); assertEquals(model.containsKey(i), entry != null); if (entry != null) { assertTrue(test.asMapOfRanges().entrySet().contains(entry)); } } for (Range<Integer> range : test.asMapOfRanges().keySet()) { assertFalse(range.isEmpty()); } }
public void testAll() { Range<Integer> range = Range.all(); assertTrue(range.contains(Integer.MIN_VALUE)); assertTrue(range.contains(Integer.MAX_VALUE)); assertUnboundedBelow(range); assertUnboundedAbove(range); assertFalse(range.isEmpty()); assertEquals("(-\u221e..+\u221e)", range.toString()); assertSame(range, reserializeAndAssert(range)); assertSame(range, Range.all()); }
public void testGreaterThan() { Range<Integer> range = Range.greaterThan(5); assertFalse(range.contains(5)); assertTrue(range.contains(6)); assertTrue(range.contains(Integer.MAX_VALUE)); assertTrue(range.hasLowerBound()); assertEquals(5, (int) range.lowerEndpoint()); assertEquals(OPEN, range.lowerBoundType()); assertUnboundedAbove(range); assertFalse(range.isEmpty()); assertEquals("(5..+\u221e)", range.toString()); reserializeAndAssert(range); }
public void testAtLeast() { Range<Integer> range = Range.atLeast(6); assertFalse(range.contains(5)); assertTrue(range.contains(6)); assertTrue(range.contains(Integer.MAX_VALUE)); assertTrue(range.hasLowerBound()); assertEquals(6, (int) range.lowerEndpoint()); assertEquals(CLOSED, range.lowerBoundType()); assertUnboundedAbove(range); assertFalse(range.isEmpty()); assertEquals("[6..+\u221e)", range.toString()); reserializeAndAssert(range); }
public void testAtMost() { Range<Integer> range = Range.atMost(4); assertTrue(range.contains(Integer.MIN_VALUE)); assertTrue(range.contains(4)); assertFalse(range.contains(5)); assertUnboundedBelow(range); assertTrue(range.hasUpperBound()); assertEquals(4, (int) range.upperEndpoint()); assertEquals(CLOSED, range.upperBoundType()); assertFalse(range.isEmpty()); assertEquals("(-\u221e..4]", range.toString()); reserializeAndAssert(range); }
public void testLessThan() { Range<Integer> range = Range.lessThan(5); assertTrue(range.contains(Integer.MIN_VALUE)); assertTrue(range.contains(4)); assertFalse(range.contains(5)); assertUnboundedBelow(range); assertTrue(range.hasUpperBound()); assertEquals(5, (int) range.upperEndpoint()); assertEquals(OPEN, range.upperBoundType()); assertFalse(range.isEmpty()); assertEquals("(-\u221e..5)", range.toString()); reserializeAndAssert(range); }
public void testSingleton() { Range<Integer> range = Range.closed(4, 4); assertFalse(range.contains(3)); assertTrue(range.contains(4)); assertFalse(range.contains(5)); assertTrue(range.hasLowerBound()); assertEquals(4, (int) range.lowerEndpoint()); assertEquals(CLOSED, range.lowerBoundType()); assertTrue(range.hasUpperBound()); assertEquals(4, (int) range.upperEndpoint()); assertEquals(CLOSED, range.upperBoundType()); assertFalse(range.isEmpty()); assertEquals("[4..4]", range.toString()); reserializeAndAssert(range); }
public void testSpanTwoRanges() { for (Range<Integer> range1 : RANGES) { for (Range<Integer> range2 : RANGES) { if (!range1.isConnected(range2) || range1.intersection(range2).isEmpty()) { RangeMap<Integer, Integer> rangemap = ImmutableRangeMap.<Integer, Integer>builder().put(range1, 1).put(range2, 2).build(); assertEquals(range1.span(range2), rangemap.span()); } } } }
public void testEmpty1() { Range<Integer> range = Range.closedOpen(4, 4); assertFalse(range.contains(3)); assertFalse(range.contains(4)); assertFalse(range.contains(5)); assertTrue(range.hasLowerBound()); assertEquals(4, (int) range.lowerEndpoint()); assertEquals(CLOSED, range.lowerBoundType()); assertTrue(range.hasUpperBound()); assertEquals(4, (int) range.upperEndpoint()); assertEquals(OPEN, range.upperBoundType()); assertTrue(range.isEmpty()); assertEquals("[4..4)", range.toString()); reserializeAndAssert(range); }
public void testClosed() { Range<Integer> range = Range.closed(5, 7); checkContains(range); assertTrue(range.hasLowerBound()); assertEquals(5, (int) range.lowerEndpoint()); assertEquals(CLOSED, range.lowerBoundType()); assertTrue(range.hasUpperBound()); assertEquals(7, (int) range.upperEndpoint()); assertEquals(CLOSED, range.upperBoundType()); assertFalse(range.isEmpty()); assertEquals("[5..7]", range.toString()); reserializeAndAssert(range); }
public void testOpen() { Range<Integer> range = Range.open(4, 8); checkContains(range); assertTrue(range.hasLowerBound()); assertEquals(4, (int) range.lowerEndpoint()); assertEquals(OPEN, range.lowerBoundType()); assertTrue(range.hasUpperBound()); assertEquals(8, (int) range.upperEndpoint()); assertEquals(OPEN, range.upperBoundType()); assertFalse(range.isEmpty()); assertEquals("(4..8)", range.toString()); reserializeAndAssert(range); }
public void testClosedOpen() { Range<Integer> range = Range.closedOpen(5, 8); checkContains(range); assertTrue(range.hasLowerBound()); assertEquals(5, (int) range.lowerEndpoint()); assertEquals(CLOSED, range.lowerBoundType()); assertTrue(range.hasUpperBound()); assertEquals(8, (int) range.upperEndpoint()); assertEquals(OPEN, range.upperBoundType()); assertFalse(range.isEmpty()); assertEquals("[5..8)", range.toString()); reserializeAndAssert(range); }
public void testOpenClosed() { Range<Integer> range = Range.openClosed(4, 7); checkContains(range); assertTrue(range.hasLowerBound()); assertEquals(4, (int) range.lowerEndpoint()); assertEquals(OPEN, range.lowerBoundType()); assertTrue(range.hasUpperBound()); assertEquals(7, (int) range.upperEndpoint()); assertEquals(CLOSED, range.upperBoundType()); assertFalse(range.isEmpty()); assertEquals("(4..7]", range.toString()); reserializeAndAssert(range); }