@Override public Range<C> get(int index) { checkElementIndex(index, length); if (index == 0 || index == length - 1) { return ranges.get(index + fromIndex).intersection(range); } else { return ranges.get(index + fromIndex); } }
@Override public Range<K> get(int index) { checkElementIndex(index, len); if (index == 0 || index == len - 1) { return ranges.get(index + off).intersection(range); } else { return ranges.get(index + off); } }
@Override protected Entry<Cut<C>, Range<C>> computeNext() { if (!completeRangeItr.hasNext()) { return endOfData(); } Range<C> nextRange = completeRangeItr.next(); if (upperBoundOnLowerBounds.isLessThan(nextRange.lowerBound)) { return endOfData(); } else { nextRange = nextRange.intersection(restriction); return Maps.immutableEntry(nextRange.lowerBound, nextRange); } } };
@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(); }
@Override public boolean intersects(Range<C> otherRange) { int ceilingIndex = SortedLists.binarySearch( ranges, Range.<C>lowerBoundFn(), otherRange.lowerBound, Ordering.natural(), ANY_PRESENT, NEXT_HIGHER); if (ceilingIndex < ranges.size() && ranges.get(ceilingIndex).isConnected(otherRange) && !ranges.get(ceilingIndex).intersection(otherRange).isEmpty()) { return true; } return ceilingIndex > 0 && ranges.get(ceilingIndex - 1).isConnected(otherRange) && !ranges.get(ceilingIndex - 1).intersection(otherRange).isEmpty(); }
@Override protected Entry<Cut<C>, Range<C>> computeNext() { if (!completeRangeItr.hasNext()) { return endOfData(); } Range<C> nextRange = completeRangeItr.next(); if (restriction.lowerBound.compareTo(nextRange.upperBound) >= 0) { return endOfData(); } nextRange = nextRange.intersection(restriction); if (lowerBoundWindow.contains(nextRange.lowerBound)) { return Maps.immutableEntry(nextRange.lowerBound, nextRange); } else { return endOfData(); } } };
private NavigableMap<Cut<C>, Range<C>> subMap(Range<Cut<C>> subWindow) { if (!complementLowerBoundWindow.isConnected(subWindow)) { return ImmutableSortedMap.of(); } else { subWindow = subWindow.intersection(complementLowerBoundWindow); return new ComplementRangesByLowerBound<C>(positiveRangesByLowerBound, subWindow); } }
private NavigableMap<Cut<C>, Range<C>> subMap(Range<Cut<C>> window) { if (window.isConnected(upperBoundWindow)) { return new RangesByUpperBound<C>(rangesByLowerBound, window.intersection(upperBoundWindow)); } else { return ImmutableSortedMap.of(); } }
@Override public ImmutableRangeMap<K, V> subRangeMap(Range<K> subRange) { if (range.isConnected(subRange)) { return outer.subRangeMap(subRange.intersection(range)); } else { return ImmutableRangeMap.of(); } } };
private ContiguousSet<C> intersectionInCurrentDomain(Range<C> other) { return range.isConnected(other) ? ContiguousSet.create(range.intersection(other), domain) : new EmptyContiguousSet<C>(domain); }
private NavigableMap<Cut<C>, Range<C>> subMap(Range<Cut<C>> window) { if (!window.isConnected(lowerBoundWindow)) { return ImmutableSortedMap.of(); } else { return new SubRangeSetRangesByLowerBound<C>( lowerBoundWindow.intersection(window), restriction, rangesByLowerBound); } }
public void testIntersection_empty() { Range<Integer> range = Range.closedOpen(3, 3); assertEquals(range, range.intersection(range)); try { range.intersection(Range.open(3, 5)); fail(); } catch (IllegalArgumentException expected) { } try { range.intersection(Range.closed(0, 2)); fail(); } catch (IllegalArgumentException expected) { } }
public void testIntersection_singleton() { Range<Integer> range = Range.closed(3, 3); assertEquals(range, range.intersection(range)); assertEquals(range, range.intersection(Range.atMost(4))); assertEquals(range, range.intersection(Range.atMost(3))); assertEquals(range, range.intersection(Range.atLeast(3))); assertEquals(range, range.intersection(Range.atLeast(2))); assertEquals(Range.closedOpen(3, 3), range.intersection(Range.lessThan(3))); assertEquals(Range.openClosed(3, 3), range.intersection(Range.greaterThan(3))); try { range.intersection(Range.atLeast(4)); fail(); } catch (IllegalArgumentException expected) { } try { range.intersection(Range.atMost(2)); fail(); } catch (IllegalArgumentException expected) { } }
public void testIntersection_deFactoEmpty() { Range<Integer> range = Range.open(3, 4); assertEquals(range, range.intersection(range)); assertEquals(Range.openClosed(3, 3), range.intersection(Range.atMost(3))); assertEquals(Range.closedOpen(4, 4), range.intersection(Range.atLeast(4))); try { range.intersection(Range.lessThan(3)); fail(); } catch (IllegalArgumentException expected) { } try { range.intersection(Range.greaterThan(4)); fail(); } catch (IllegalArgumentException expected) { } range = Range.closed(3, 4); assertEquals(Range.openClosed(4, 4), range.intersection(Range.greaterThan(4))); }
private RangeSet<Integer> expectedSubRangeSet( RangeSet<Integer> rangeSet, Range<Integer> subRange) { RangeSet<Integer> expected = TreeRangeSet.create(); for (Range<Integer> range : rangeSet.asRanges()) { if (range.isConnected(subRange)) { expected.add(range.intersection(subRange)); } } return expected; }
public void testGetEntry() { for (Range<Integer> range1 : RANGES) { for (Range<Integer> range2 : RANGES) { if (!range1.isConnected(range2) || range1.intersection(range2).isEmpty()) { ImmutableRangeMap<Integer, Integer> rangeMap = ImmutableRangeMap.<Integer, Integer>builder().put(range1, 1).put(range2, 2).build(); for (int i = MIN_BOUND; i <= MAX_BOUND; i++) { Entry<Range<Integer>, Integer> expectedEntry = null; if (range1.contains(i)) { expectedEntry = Maps.immutableEntry(range1, 1); } else if (range2.contains(i)) { expectedEntry = Maps.immutableEntry(range2, 2); } assertEquals(expectedEntry, rangeMap.getEntry(i)); } } } } }
public void testGet() { for (Range<Integer> range1 : RANGES) { for (Range<Integer> range2 : RANGES) { if (!range1.isConnected(range2) || range1.intersection(range2).isEmpty()) { ImmutableRangeMap<Integer, Integer> rangeMap = ImmutableRangeMap.<Integer, Integer>builder().put(range1, 1).put(range2, 2).build(); for (int i = MIN_BOUND; i <= MAX_BOUND; i++) { Integer expectedValue = null; if (range1.contains(i)) { expectedValue = 1; } else if (range2.contains(i)) { expectedValue = 2; } assertEquals(expectedValue, rangeMap.get(i)); } } } } }
public void testIntersects(RangeSet<Integer> rangeSet) { for (Range<Integer> query : QUERY_RANGES) { boolean expectIntersect = false; for (Range<Integer> expectedRange : rangeSet.asRanges()) { if (expectedRange.isConnected(query) && !expectedRange.intersection(query).isEmpty()) { expectIntersect = true; break; } } assertEquals( rangeSet + " was incorrect on intersects(" + query + ")", expectIntersect, rangeSet.intersects(query)); } }
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 testOverlapRejection() { for (Range<Integer> range1 : RANGES) { for (Range<Integer> range2 : RANGES) { boolean expectRejection = range1.isConnected(range2) && !range1.intersection(range2).isEmpty(); ImmutableRangeMap.Builder<Integer, Integer> builder = ImmutableRangeMap.builder(); builder.put(range1, 1).put(range2, 2); try { ImmutableRangeMap<Integer, Integer> unused = builder.build(); assertFalse(expectRejection); } catch (IllegalArgumentException e) { assertTrue(expectRejection); } } } }