public static <C extends Comparable<?>> Range<C> merge(Range<C> a, Range<C> b) { if (a == null && b == null) { return null; } else if (a == null || b == null) { return a == null ? b : a; } else { return a.span(b); } }
/** Returns the range that spans the given range and entry, if the entry can be coalesced. */ private static <K extends Comparable, V> Range<K> coalesce( Range<K> range, V value, @Nullable Entry<Cut<K>, RangeMapEntry<K, V>> entry) { if (entry != null && entry.getValue().getKey().isConnected(range) && entry.getValue().getValue().equals(value)) { return range.span(entry.getValue().getKey()); } return range; }
/** Returns the range that spans the given range and entry, if the entry can be coalesced. */ private static <K extends Comparable, V> Range<K> coalesce( Range<K> range, V value, @NullableDecl Entry<Cut<K>, RangeMapEntry<K, V>> entry) { if (entry != null && entry.getValue().getKey().isConnected(range) && entry.getValue().getValue().equals(value)) { return range.span(entry.getValue().getKey()); } return range; }
/** Returns the range that spans the given range and entry, if the entry can be coalesced. */ private static <K extends Comparable, V> Range<K> coalesce( Range<K> range, V value, @NullableDecl Entry<Cut<K>, RangeMapEntry<K, V>> entry) { if (entry != null && entry.getValue().getKey().isConnected(range) && entry.getValue().getValue().equals(value)) { return range.span(entry.getValue().getKey()); } return range; }
range, nextRange); range = range.span(peekingItr.next()); } else { break;
private static Range<Integer> union(Range<Integer> x, Range<Integer> y) { return x.isEmpty() ? y : y.isEmpty() ? x : x.span(y).canonical(INTEGERS); }
range, nextRange); range = range.span(peekingItr.next()); } else { break;
assertEquals(Range.closed(0, 8), range.span(Range.closed(0, 2))); assertEquals(Range.atMost(8), range.span(Range.atMost(2))); assertEquals(Range.closed(2, 8), range.span(Range.closedOpen(2, 4))); assertEquals(Range.atMost(8), range.span(Range.lessThan(4))); assertEquals(Range.closed(2, 8), range.span(Range.closed(2, 6))); assertEquals(Range.atMost(8), range.span(Range.atMost(6))); assertEquals(range, range.span(Range.closed(4, 6))); assertEquals(range, range.span(Range.closed(5, 7))); assertEquals(range, range.span(Range.closed(6, 8))); assertEquals(range, range.span(range)); assertEquals(Range.closed(4, 10), range.span(Range.closed(4, 10))); assertEquals(Range.atLeast(4), range.span(Range.atLeast(4))); assertEquals(Range.closed(2, 8), range.span(Range.closed(2, 8))); assertEquals(Range.atMost(8), range.span(Range.atMost(8))); assertEquals(Range.closed(2, 10), range.span(Range.closed(2, 10))); assertEquals(Range.<Integer>all(), range.span(Range.<Integer>all())); assertEquals(Range.closed(4, 10), range.span(Range.closed(6, 10))); assertEquals(Range.atLeast(4), range.span(Range.atLeast(6)));
private static Range<Integer> union(Range<Integer> x, Range<Integer> y) { return x.isEmpty() ? y : y.isEmpty() ? x : x.span(y).canonical(DiscreteDomain.integers()); }
range, nextRange); range = range.span(peekingItr.next()); } else { break;
expectedSpan = itr.next(); while (itr.hasNext()) { expectedSpan = expectedSpan.span(itr.next());
private static void doPairTest(Range<Integer> a, Range<Integer> b) { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(a); rangeSet.add(b); if (a.isEmpty() && b.isEmpty()) { assertThat(rangeSet.asRanges()).isEmpty(); } else if (a.isEmpty()) { assertThat(rangeSet.asRanges()).contains(b); } else if (b.isEmpty()) { assertThat(rangeSet.asRanges()).contains(a); } else if (a.isConnected(b)) { assertThat(rangeSet.asRanges()).containsExactly(a.span(b)); } else { if (a.lowerEndpoint() < b.lowerEndpoint()) { assertThat(rangeSet.asRanges()).containsExactly(a, b).inOrder(); } else { assertThat(rangeSet.asRanges()).containsExactly(b, a).inOrder(); } } }
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 testSpanTwoRanges() { for (Range<Integer> range1 : RANGES) { for (Range<Integer> range2 : RANGES) { RangeMap<Integer, Integer> rangeMap = TreeRangeMap.create(); rangeMap.put(range1, 1); rangeMap.put(range2, 2); Range<Integer> expected; if (range1.isEmpty()) { if (range2.isEmpty()) { expected = null; } else { expected = range2; } } else { if (range2.isEmpty()) { expected = range1; } else { expected = range1.span(range2); } } try { assertEquals(expected, rangeMap.span()); assertNotNull(expected); } catch (NoSuchElementException e) { assertNull(expected); } } } }
/** Returns the range that spans the given range and entry, if the entry can be coalesced. */ private static <K extends Comparable, V> Range<K> coalesce( Range<K> range, V value, @Nullable Entry<Cut<K>, RangeMapEntry<K, V>> entry) { if (entry != null && entry.getValue().getKey().isConnected(range) && entry.getValue().getValue().equals(value)) { return range.span(entry.getValue().getKey()); } return range; }
/** Returns the range that spans the given range and entry, if the entry can be coalesced. */ private static <K extends Comparable, V> Range<K> coalesce( Range<K> range, V value, @NullableDecl Entry<Cut<K>, RangeMapEntry<K, V>> entry) { if (entry != null && entry.getValue().getKey().isConnected(range) && entry.getValue().getValue().equals(value)) { return range.span(entry.getValue().getKey()); } return range; }
@Override public Range<Double> apply(@Nullable Range<Double> range) { if (!range.hasUpperBound()) return range; return range.span(Ranges.closed(range.upperEndpoint(), adjustDoubleForSearch(range.upperEndpoint()))); } };
@Override public Range<Long> apply(@Nullable Range<Long> range) { if (!range.hasUpperBound()) return range; return range.span(Ranges.closed(range.upperEndpoint(), adjustLongForSearch(range.upperEndpoint()))); } };
@Override public Range<DateTime> apply(@Nullable Range<DateTime> range) { if (!range.hasUpperBound()) return range; return range.span(Ranges.closed(range.upperEndpoint(), adjustDateTimeForSearch(range.upperEndpoint()))); } };
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()); } } } }