/** * Adds all of the specified ranges to this range set (optional operation). After this operation, * this range set is the minimal range set that {@linkplain #enclosesAll(RangeSet) encloses} both * the original range set and each range in {@code other}. * * <p>This is equivalent to calling {@link #add} on each of the ranges in {@code other} in turn. * * @throws UnsupportedOperationException if this range set does not support the {@code addAll} * operation * @since 21.0 */ default void addAll(Iterable<Range<C>> ranges) { for (Range<C> range : ranges) { add(range); } }
public void testAddAll() { RangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(3, 10)); rangeSet.addAll(Arrays.asList(Range.open(1, 3), Range.closed(5, 8), Range.closed(9, 11))); assertThat(rangeSet.asRanges()).containsExactly(Range.openClosed(1, 11)).inOrder(); }
/** * Unions a set of ranges, or returns null if the set is empty. */ public static <T extends Comparable<T>> RangeSet<T> unionRanges(final Iterable<Range<T>> ranges) { RangeSet<T> rangeSet = null; for (Range<T> range : ranges) { if (rangeSet == null) { rangeSet = TreeRangeSet.create(); } rangeSet.add(range); } return rangeSet; }
private void excludeFromCodeFixes(DocTree tree) { int endPos = getEndPosition(tree, state); if (endPos != Position.NOPOS) { dontEmitCodeFix.add(Range.closed(getStartPosition(tree, state), endPos)); } } }
private void recoverIndividualDeletedMessages(List<MLDataFormats.MessageRange> individualDeletedMessagesList) { lock.writeLock().lock(); try { individualDeletedMessages.clear(); individualDeletedMessagesList.forEach(messageRange -> individualDeletedMessages .add(Range.openClosed(new PositionImpl(messageRange.getLowerEndpoint()), new PositionImpl(messageRange.getUpperEndpoint())))); } finally { lock.writeLock().unlock(); } }
@Override public RangeSet<String> getDimensionRangeSet(String dimension) { if (!Objects.equals(getDimension(), dimension) || getExtractionFn() != null) { return null; } RangeSet<String> retSet = TreeRangeSet.create(); String valueEquivalent = NullHandling.nullToEmptyIfNeeded(value); if (valueEquivalent == null) { // Case when SQL compatible null handling is enabled // Nulls are less than empty String in segments retSet.add(Range.lessThan("")); } else { retSet.add(Range.singleton(valueEquivalent)); } return retSet; }
@Override public RangeSet<String> getDimensionRangeSet(String dimension) { if (!Objects.equals(getDimension(), dimension) || getExtractionFn() != null) { return null; } RangeSet<String> retSet = TreeRangeSet.create(); for (String value : values) { String valueEquivalent = NullHandling.nullToEmptyIfNeeded(value); if (valueEquivalent == null) { // Case when SQL compatible null handling is enabled // Range.singleton(null) is invalid, so use the fact that // only null values are less than empty string. retSet.add(Range.lessThan("")); } else { retSet.add(Range.singleton(valueEquivalent)); } } return retSet; }
/** * Intersects a set of ranges, or returns null if the set is empty. */ public static <T extends Comparable<T>> RangeSet<T> intersectRanges(final Iterable<Range<T>> ranges) { RangeSet<T> rangeSet = null; for (final Range<T> range : ranges) { if (rangeSet == null) { rangeSet = TreeRangeSet.create(); rangeSet.add(range); } else { rangeSet = TreeRangeSet.create(rangeSet.subRangeSet(range)); } } return rangeSet; }
public static RangeSet<Long> fromIntervals(final Iterable<Interval> intervals) { final RangeSet<Long> retVal = TreeRangeSet.create(); for (Interval interval : intervals) { retVal.add(Range.closedOpen(interval.getStartMillis(), interval.getEndMillis())); } return retVal; }
@Override public void markForPartialFormat(Token start, Token end) { int lo = JavaOutput.startTok(start).getIndex(); int hi = JavaOutput.endTok(end).getIndex(); partialFormatRanges.add(Range.closed(lo, hi)); }
private RangeSet<Integer> expectedComplement(RangeSet<Integer> rangeSet) { RangeSet<Integer> expected = TreeRangeSet.create(); expected.add(Range.<Integer>all()); expected.removeAll(rangeSet); return expected; }
public void testRemoveAll() { RangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(3, 10)); rangeSet.removeAll(Arrays.asList(Range.open(1, 3), Range.closed(5, 8), Range.closed(9, 11))); assertThat(rangeSet.asRanges()) .containsExactly(Range.closedOpen(3, 5), Range.open(8, 9)) .inOrder(); }
@GwtIncompatible // SerializableTester public void testSerialization() { RangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(3, 10)); rangeSet.remove(Range.open(5, 7)); SerializableTester.reserializeAndAssert(rangeSet); } }
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 testRangeContaining1() { RangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(3, 10)); assertEquals(Range.closed(3, 10), rangeSet.rangeContaining(5)); assertTrue(rangeSet.contains(5)); assertNull(rangeSet.rangeContaining(1)); assertFalse(rangeSet.contains(1)); }
public void testAddUnsupported() { RangeSet<Integer> rangeSet = ImmutableRangeSet.<Integer>builder() .add(Range.closed(5, 8)) .add(Range.closedOpen(1, 3)) .build(); try { rangeSet.add(Range.open(3, 4)); fail(); } catch (UnsupportedOperationException expected) { // success } }
public RangeSet<Integer> characterRangesToTokenRanges(Collection<Range<Integer>> characterRanges) throws FormatterException { RangeSet<Integer> tokenRangeSet = TreeRangeSet.create(); for (Range<Integer> characterRange0 : characterRanges) { Range<Integer> characterRange = characterRange0.canonical(DiscreteDomain.integers()); tokenRangeSet.add( characterRangeToTokenRange( characterRange.lowerEndpoint(), characterRange.upperEndpoint() - characterRange.lowerEndpoint())); } return tokenRangeSet; } }
public void testRangeContaining2() { RangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(3, 10)); rangeSet.remove(Range.open(5, 7)); assertEquals(Range.closed(3, 5), rangeSet.rangeContaining(5)); assertTrue(rangeSet.contains(5)); assertEquals(Range.closed(7, 10), rangeSet.rangeContaining(8)); assertTrue(rangeSet.contains(8)); assertNull(rangeSet.rangeContaining(6)); assertFalse(rangeSet.contains(6)); }
for (Range<Integer> range : rangeSet.asRanges()) { if (range.isConnected(subRange)) { expected.add(range.intersection(subRange));
public void testSingleBoundedRange() { ImmutableRangeSet<Integer> rangeSet = ImmutableRangeSet.of(Range.closedOpen(1, 5)); assertThat(rangeSet.asRanges()).contains(Range.closedOpen(1, 5)); assertTrue(rangeSet.intersects(Range.closed(3, 4))); assertTrue(rangeSet.intersects(Range.closedOpen(0, 2))); assertTrue(rangeSet.intersects(Range.closedOpen(3, 7))); assertTrue(rangeSet.intersects(Range.greaterThan(2))); assertFalse(rangeSet.intersects(Range.greaterThan(7))); assertTrue(rangeSet.encloses(Range.closed(3, 4))); assertTrue(rangeSet.encloses(Range.closedOpen(1, 4))); assertTrue(rangeSet.encloses(Range.closedOpen(1, 5))); assertFalse(rangeSet.encloses(Range.greaterThan(2))); assertTrue(rangeSet.contains(3)); assertFalse(rangeSet.contains(5)); assertFalse(rangeSet.contains(0)); RangeSet<Integer> expectedComplement = TreeRangeSet.create(); expectedComplement.add(Range.lessThan(1)); expectedComplement.add(Range.atLeast(5)); assertEquals(expectedComplement, rangeSet.complement()); }