Refine search
/** 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())); }
public void testToImmutableRangeSet() { Range<Integer> rangeOne = Range.closedOpen(1, 5); Range<Integer> rangeTwo = Range.openClosed(6, 7); ImmutableRangeSet<Integer> ranges = ImmutableRangeSet.copyOf(ImmutableList.of(rangeOne, rangeTwo)); CollectorTester.of(ImmutableRangeSet.<Integer>toImmutableRangeSet()) .expectCollects(ranges, rangeOne, rangeTwo); } }
@Override public Set<BigInteger> create(Object... elements) { ImmutableRangeSet.Builder<BigInteger> builder = ImmutableRangeSet.builder(); for (Object o : elements) { BigInteger i = (BigInteger) o; builder.add(Range.closedOpen(i, i.add(BigInteger.ONE))); } return builder.build().asSet(DiscreteDomain.bigIntegers()); } }
Object readResolve() { return new ImmutableRangeSet<C>(ranges).asSet(domain); } }
/** Returns a view of the intersection of this range set with the given range. */ @Override public ImmutableRangeSet<C> subRangeSet(Range<C> range) { if (!isEmpty()) { Range<C> span = span(); if (range.encloses(span)) { return this; } else if (range.isConnected(span)) { return new ImmutableRangeSet<C>(intersectRanges(range)); } } return of(); }
/** * 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)); } }
new ImmutableRangeSet<>(ImmutableList.<Range<Comparable<?>>>of()); new ImmutableRangeSet<>(ImmutableList.of(Range.<Comparable<?>>all())); if (rangeSet.isEmpty()) { return of(); } else if (rangeSet.encloses(Range.<C>all())) { return all(); return new ImmutableRangeSet.Builder<C>().addAll(ranges).build(); return this; } else if (range.isConnected(span)) { return new ImmutableRangeSet<C>(intersectRanges(range));
@Test public void testSimpleFilter() { RangeSet expected1 = rangeSet(point("a")); Assert.assertEquals(expected1, selector1.getDimensionRangeSet("dim1")); Assert.assertNull(selector1.getDimensionRangeSet("dim2")); RangeSet expected2 = rangeSet(point(null)); Assert.assertEquals(expected2, selector5.getDimensionRangeSet("dim1")); RangeSet expected3 = rangeSet(ImmutableList.of(point("testing"), point("this"), point("filter"), point("tillend"))); Assert.assertEquals(expected3, in1.getDimensionRangeSet("dim1")); RangeSet expected4 = rangeSet(ImmutableList.of(point("null"), point(null))); Assert.assertEquals(expected4, in3.getDimensionRangeSet("dim1")); RangeSet expected5 = ImmutableRangeSet.of(Range.closed("from", "to")); Assert.assertEquals(expected5, bound1.getDimensionRangeSet("dim1")); RangeSet expected6 = ImmutableRangeSet.of(Range.atMost("tillend")); Assert.assertEquals(expected6, bound2.getDimensionRangeSet("dim1")); RangeSet expected7 = ImmutableRangeSet.of(Range.greaterThan("notincluded")); Assert.assertEquals(expected7, bound3.getDimensionRangeSet("dim1")); Assert.assertNull(other1.getDimensionRangeSet("someDim")); Assert.assertNull(other2.getDimensionRangeSet("someOtherDim")); Assert.assertNull(other3.getDimensionRangeSet("dim")); Assert.assertNull(interval1.getDimensionRangeSet(ColumnHolder.TIME_COLUMN_NAME)); Assert.assertNull(interval2.getDimensionRangeSet("dim1")); }
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));
@Override public ImmutableRangeSet<C> complement() { ImmutableRangeSet<C> result = complement; if (result != null) { return result; } else if (ranges.isEmpty()) { return complement = all(); } else if (ranges.size() == 1 && ranges.get(0).equals(Range.all())) { return complement = of(); } else { ImmutableList<Range<C>> complementRanges = new ComplementRanges(); result = complement = new ImmutableRangeSet<C>(complementRanges, this); } return result; }
private RangeSet<Integer> characterRanges(String input) { final RangeSet<Integer> characterRanges = TreeRangeSet.create(); if (parameters.lines().isEmpty() && parameters.offsets().isEmpty()) { characterRanges.add(Range.closedOpen(0, input.length())); return characterRanges; } characterRanges.addAll(Formatter.lineRangesToCharRanges(input, parameters.lines())); for (int i = 0; i < parameters.offsets().size(); i++) { Integer length = parameters.lengths().get(i); if (length == 0) { // 0 stands for "format the line under the cursor" length = 1; } characterRanges.add( Range.closedOpen(parameters.offsets().get(i), parameters.offsets().get(i) + length)); } return characterRanges; } }
ImmutableList.Builder<Range<C>> mergedRangesBuilder = new ImmutableList.Builder<>(ranges.size()); Collections.sort(ranges, Range.<C>rangeLexOrdering()); PeekingIterator<Range<C>> peekingItr = Iterators.peekingIterator(ranges.iterator()); while (peekingItr.hasNext()) { while (peekingItr.hasNext()) { Range<C> nextRange = peekingItr.peek(); if (range.isConnected(nextRange)) { checkArgument( range.intersection(nextRange).isEmpty(), "Overlapping ranges not permitted but found %s overlapping %s", range, if (mergedRanges.isEmpty()) { return of(); } else if (mergedRanges.size() == 1 && Iterables.getOnlyElement(mergedRanges).equals(Range.all())) { return all(); } else { return new ImmutableRangeSet<C>(mergedRanges);
subsets: for (Set<Range<Integer>> subset : Sets.powerSet(ranges)) { assertEquals(TreeRangeSet.create(subset), ImmutableRangeSet.unionOf(subset)); ImmutableRangeSet.Builder<Integer> builder = ImmutableRangeSet.builder(); for (Range<Integer> other : mutable.asRanges()) { if (other.isConnected(range) && !other.intersection(range).isEmpty()) { overlaps = true; RangeSet<Integer> copy = ImmutableRangeSet.copyOf(subset); fail(); } catch (IllegalArgumentException expected) { RangeSet<Integer> copy = ImmutableRangeSet.copyOf(subset); assertEquals(mutable, copy); ImmutableRangeSet<Integer> built = builder.build(); assertEquals(mutable, built); assertEquals(ImmutableRangeSet.copyOf(mutable), built); assertEquals(mutable.complement(), built.complement()); assertEquals(mutable.contains(i), built.contains(i)); SerializableTester.reserializeAndAssert(built.asRanges());
Object readResolve() { if (ranges.isEmpty()) { return of(); } else if (ranges.equals(ImmutableList.of(Range.all()))) { return all(); } else { return new ImmutableRangeSet<C>(ranges); } } }
public void testSingleBoundedBelowRange() { ImmutableRangeSet<Integer> rangeSet = ImmutableRangeSet.of(Range.greaterThan(2)); assertThat(rangeSet.asRanges()).contains(Range.greaterThan(2)); assertTrue(rangeSet.intersects(Range.closed(3, 4))); assertTrue(rangeSet.intersects(Range.closedOpen(1, 5))); assertFalse(rangeSet.intersects(Range.lessThan(1))); assertTrue(rangeSet.intersects(Range.greaterThan(1))); assertTrue(rangeSet.intersects(Range.greaterThan(3))); assertTrue(rangeSet.encloses(Range.closed(3, 4))); assertTrue(rangeSet.encloses(Range.greaterThan(3))); assertFalse(rangeSet.encloses(Range.closedOpen(1, 5))); assertTrue(rangeSet.contains(3)); assertTrue(rangeSet.contains(5)); assertFalse(rangeSet.contains(0)); assertFalse(rangeSet.contains(2)); assertEquals(ImmutableRangeSet.of(Range.atMost(2)), rangeSet.complement()); }
public void testMultipleBoundedAboveRanges() { ImmutableRangeSet<Integer> rangeSet = ImmutableRangeSet.<Integer>builder() .add(Range.atMost(0)) .add(Range.closedOpen(2, 5)) .build(); assertThat(rangeSet.asRanges()) .containsExactly(Range.atMost(0), Range.closedOpen(2, 5)) .inOrder(); assertTrue(rangeSet.intersects(Range.closed(2, 4))); assertTrue(rangeSet.intersects(Range.open(-5, -2))); assertTrue(rangeSet.intersects(Range.closed(1, 8))); assertFalse(rangeSet.intersects(Range.singleton(1))); assertFalse(rangeSet.intersects(Range.greaterThan(5))); assertTrue(rangeSet.encloses(Range.closed(2, 4))); assertTrue(rangeSet.encloses(Range.open(-5, -2))); assertFalse(rangeSet.encloses(Range.closed(1, 8))); assertFalse(rangeSet.encloses(Range.greaterThan(5))); RangeSet<Integer> expectedComplement = ImmutableRangeSet.<Integer>builder().add(Range.open(0, 2)).add(Range.atLeast(5)).build(); assertEquals(expectedComplement, rangeSet.complement()); }
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()); }
public void testMultipleBoundedBelowRanges() { ImmutableRangeSet<Integer> rangeSet = ImmutableRangeSet.<Integer>builder() .add(Range.greaterThan(6)) .add(Range.closedOpen(1, 3)) .build(); assertThat(rangeSet.asRanges()) .containsExactly(Range.closedOpen(1, 3), Range.greaterThan(6)) .inOrder(); assertTrue(rangeSet.intersects(Range.closed(1, 2))); assertTrue(rangeSet.intersects(Range.open(6, 8))); assertFalse(rangeSet.intersects(Range.closed(3, 6))); assertTrue(rangeSet.intersects(Range.greaterThan(5))); assertFalse(rangeSet.intersects(Range.lessThan(1))); assertTrue(rangeSet.encloses(Range.closed(1, 2))); assertTrue(rangeSet.encloses(Range.open(6, 8))); assertFalse(rangeSet.encloses(Range.closed(1, 8))); assertFalse(rangeSet.encloses(Range.greaterThan(5))); RangeSet<Integer> expectedComplement = ImmutableRangeSet.<Integer>builder().add(Range.lessThan(1)).add(Range.closed(3, 6)).build(); assertEquals(expectedComplement, rangeSet.complement()); }