Refine search
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(); }
/** Returns an immutable copy of the specified {@code RangeSet}. */ public static <C extends Comparable> ImmutableRangeSet<C> copyOf(RangeSet<C> rangeSet) { checkNotNull(rangeSet); if (rangeSet.isEmpty()) { return of(); } else if (rangeSet.encloses(Range.<C>all())) { return all(); } if (rangeSet instanceof ImmutableRangeSet) { ImmutableRangeSet<C> immutableRangeSet = (ImmutableRangeSet<C>) rangeSet; if (!immutableRangeSet.isPartialView()) { return immutableRangeSet; } } return new ImmutableRangeSet<C>(ImmutableList.copyOf(rangeSet.asRanges())); }
/** * Returns a new range set consisting of the intersection of this range set and {@code other}. * * <p>This is essentially the same as {@code * TreeRangeSet.create(this).removeAll(other.complement())} except it returns an {@code * ImmutableRangeSet}. * * @since 21.0 */ public ImmutableRangeSet<C> intersection(RangeSet<C> other) { RangeSet<C> copy = TreeRangeSet.create(this); copy.removeAll(other.complement()); return copyOf(copy); }
/** * Intersects a set of rangeSets, or returns null if the set is empty. */ public static <T extends Comparable<T>> RangeSet<T> intersectRangeSets(final Iterable<RangeSet<T>> rangeSets) { RangeSet<T> rangeSet = null; for (final RangeSet<T> set : rangeSets) { if (rangeSet == null) { rangeSet = TreeRangeSet.create(); rangeSet.addAll(set); } else { rangeSet.removeAll(set.complement()); } } return rangeSet; }
public void testIgnoresSmallerSharingNoBound() { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(1, 6)); rangeSet.add(Range.open(2, 4)); testInvariants(rangeSet); assertThat(rangeSet.asRanges()).contains(Range.closed(1, 6)); assertThat(rangeSet.complement().asRanges()) .containsExactly(Range.lessThan(1), Range.greaterThan(6)) .inOrder(); }
subsets: for (Set<Range<Integer>> subset : Sets.powerSet(ranges)) { assertEquals(TreeRangeSet.create(subset), ImmutableRangeSet.unionOf(subset)); RangeSet<Integer> mutable = TreeRangeSet.create(); ImmutableRangeSet.Builder<Integer> builder = ImmutableRangeSet.builder(); for (Range<Integer> other : mutable.asRanges()) { if (other.isConnected(range) && !other.intersection(range).isEmpty()) { overlaps = true; ImmutableRangeSet<Integer> unused = builder.add(range).build(); assertFalse(overlaps); mutable.add(range); } catch (IllegalArgumentException e) { assertTrue(overlaps); RangeSet<Integer> copy = ImmutableRangeSet.copyOf(subset); fail(); } catch (IllegalArgumentException expected) { assertEquals(mutable, built); assertEquals(ImmutableRangeSet.copyOf(mutable), built); assertEquals(mutable.complement(), built.complement()); assertEquals(mutable.contains(i), built.contains(i));
public void testFillHoleWithOverlap() { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closedOpen(1, 3)); rangeSet.add(Range.closedOpen(4, 6)); rangeSet.add(Range.closedOpen(2, 5)); testInvariants(rangeSet); assertThat(rangeSet.asRanges()).contains(Range.closedOpen(1, 6)); assertThat(rangeSet.complement().asRanges()) .containsExactly(Range.lessThan(1), Range.atLeast(6)) .inOrder(); }
public void testSubRangeSet() { ImmutableList.Builder<Range<Integer>> rangesBuilder = ImmutableList.builder(); rangesBuilder.add(Range.<Integer>all()); for (int i = -2; i <= 2; i++) { for (BoundType boundType : BoundType.values()) { rangesBuilder.add(Range.upTo(i, boundType)); rangesBuilder.add(Range.downTo(i, boundType)); if (!range1.isConnected(range2) || range1.intersection(range2).isEmpty()) { ImmutableRangeSet<Integer> rangeSet = ImmutableRangeSet.<Integer>builder().add(range1).add(range2).build(); for (Range<Integer> subRange : subRanges) { RangeSet<Integer> expected = TreeRangeSet.create(); for (Range<Integer> range : rangeSet.asRanges()) { if (range.isConnected(subRange)) { expected.add(range.intersection(subRange)); ImmutableRangeSet<Integer> subRangeSet = rangeSet.subRangeSet(subRange); assertEquals(expected, subRangeSet); assertEquals(expected.asRanges(), subRangeSet.asRanges()); if (!expected.isEmpty()) { assertEquals(expected.span(), subRangeSet.span()); assertEquals(expected.contains(i), subRangeSet.contains(i));
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()); }
RangeSet<Integer> fixedRanges = TreeRangeSet.create(); Range<Integer> range = replacement.getKey(); String replaceWith = replacement.getValue(); int start = offset + range.lowerEndpoint(); int end = offset + range.upperEndpoint(); sb.replace(start, end, replaceWith); if (!replaceWith.isEmpty()) { fixedRanges.add(Range.closedOpen(start, end)); offset += replaceWith.length() - (range.upperEndpoint() - range.lowerEndpoint()); if (!fixedRanges.isEmpty()) { try { result = new Formatter().formatSource(result, fixedRanges.asRanges()); } catch (FormatterException e) {
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)); }
ImmutableRangeSet.Builder<Integer> setBuilder = ImmutableRangeSet.builder(); setBuilder.add( Range.singleton( vpart ) ); Integer start = Integer.valueOf( rangeMultiPart[0] ); Integer end = Integer.valueOf( rangeMultiPart[1] ); Range<Integer> range = Range.closed( start, end ); if ( log.isDebug() ) { logDebug( BaseMessages.getString( PKG, "SampleRows.Log.RangeValue", range ) ); if ( data.rangeSet.contains( linesRead ) ) { if ( data.addlineField ) { data.outputRow[data.NrPrevFields] = getLinesRead(); if ( data.rangeSet.isEmpty() || linesRead >= data.rangeSet.span().upperEndpoint() ) { setOutputDone();
/** * Expand a token range to start and end on acceptable boundaries for re-formatting. * * @param iRange the {@link Range} of tokens * @return the expanded token range */ private Range<Integer> expandToBreakableRegions(Range<Integer> iRange) { // The original line range. int loTok = iRange.lowerEndpoint(); int hiTok = iRange.upperEndpoint() - 1; // Expand the token indices to formattable boundaries (e.g. edges of statements). if (!partialFormatRanges.contains(loTok) || !partialFormatRanges.contains(hiTok)) { return EMPTY_RANGE; } loTok = partialFormatRanges.rangeContaining(loTok).lowerEndpoint(); hiTok = partialFormatRanges.rangeContaining(hiTok).upperEndpoint(); return Range.closedOpen(loTok, hiTok + 1); }
if (individualDeletedMessages.contains(position) || position.compareTo(markDeletePosition) <= 0) { if (log.isDebugEnabled()) { log.debug("[{}] [{}] Position was already deleted {}", ledger.getName(), name, position); individualDeletedMessages.add(Range.openClosed(previousPosition, position)); ++messagesConsumedCounter; if (individualDeletedMessages.isEmpty()) { Range<PositionImpl> range = individualDeletedMessages.asRanges().iterator().next(); if (range.lowerEndpoint().compareTo(markDeletePosition) <= 0 || ledger .getNumberOfEntries(Range.openClosed(markDeletePosition, range.lowerEndpoint())) <= 0) {
public void testRemoveUnsupported() { RangeSet<Integer> rangeSet = ImmutableRangeSet.<Integer>builder() .add(Range.closed(5, 8)) .add(Range.closedOpen(1, 3)) .build(); try { rangeSet.remove(Range.closed(6, 7)); fail(); } catch (UnsupportedOperationException expected) { // success } }
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 void testRemoveAllUnsupported() { RangeSet<Integer> rangeSet = ImmutableRangeSet.<Integer>builder() .add(Range.closed(5, 8)) .add(Range.closedOpen(1, 3)) .build(); try { rangeSet.removeAll(ImmutableRangeSet.<Integer>of()); fail(); } catch (UnsupportedOperationException expected) { // success } try { rangeSet.removeAll(ImmutableRangeSet.of(Range.closed(6, 8))); fail(); } catch (UnsupportedOperationException expected) { // success } }