Refine search
new ImmutableRangeSet<>(ImmutableList.<Range<Comparable<?>>>of()); return new ImmutableRangeSet.Builder<C>().addAll(ranges).build();
subsets: for (Set<Range<Integer>> subset : Sets.powerSet(ranges)) { assertEquals(TreeRangeSet.create(subset), ImmutableRangeSet.unionOf(subset)); ImmutableRangeSet.Builder<Integer> builder = ImmutableRangeSet.builder(); ImmutableRangeSet<Integer> unused = builder.add(range).build(); assertFalse(overlaps); mutable.add(range); RangeSet<Integer> copy = ImmutableRangeSet.copyOf(subset); fail(); } catch (IllegalArgumentException expected) { ImmutableRangeSet<Integer> built = builder.build(); assertEquals(mutable, built); assertEquals(ImmutableRangeSet.copyOf(mutable), built);
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()); }
@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()); } }
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());
public void testUnion() { RangeSet<Integer> expected = ImmutableRangeSet.<Integer>builder() .add(Range.openClosed(0, 4)) .add(Range.closedOpen(5, 10)) .add(Range.closedOpen(12, 15)) .add(Range.openClosed(15, 17)) .add(Range.open(19, 20)) .build(); assertThat(RANGE_SET_ONE.union(RANGE_SET_TWO)).isEqualTo(expected); }
/** * Returns an {@code ImmutableRangeSet} containing each of the specified disjoint ranges. * Overlapping ranges and empty ranges are forbidden, though adjacent ranges are permitted and * will be merged. * * @throws IllegalArgumentException if any ranges overlap or are empty * @since 21.0 */ public static <C extends Comparable<?>> ImmutableRangeSet<C> copyOf(Iterable<Range<C>> ranges) { return new ImmutableRangeSet.Builder<C>().addAll(ranges).build(); }
/** * Add all ranges from the specified range set to this builder. Adjacent ranges are permitted * and will be merged, but overlapping ranges will cause an exception when {@link #build()} is * called. */ @CanIgnoreReturnValue public Builder<C> addAll(RangeSet<C> ranges) { return addAll(ranges.asRanges()); }
@CanIgnoreReturnValue Builder<C> combine(Builder<C> builder) { addAll(builder.ranges); return this; }
/** Returns a new builder for an immutable range set. */ public static <C extends Comparable<?>> Builder<C> builder() { return new Builder<C>(); }
/** * Add all of the specified ranges to this builder. Adjacent ranges are permitted and will be * merged, but overlapping ranges will cause an exception when {@link #build()} is called. * * @throws IllegalArgumentException if any inserted ranges are empty * @since 21.0 */ @CanIgnoreReturnValue public Builder<C> addAll(Iterable<Range<C>> ranges) { for (Range<C> range : ranges) { add(range); } return this; }
/** * Returns an {@code ImmutableRangeSet} containing each of the specified disjoint ranges. * Overlapping ranges and empty ranges are forbidden, though adjacent ranges are permitted and * will be merged. * * @throws IllegalArgumentException if any ranges overlap or are empty * @since 21.0 */ public static <C extends Comparable<?>> ImmutableRangeSet<C> copyOf(Iterable<Range<C>> ranges) { return new ImmutableRangeSet.Builder<C>().addAll(ranges).build(); }
/** * Parse multiple --lines flags, like {"1:12,14,20:36", "40:45,50"}. Multiple ranges can be given * with multiple --lines flags or separated by commas. A single line can be set by a single * number. Line numbers are {@code 1}-based, but are converted to the {@code 0}-based numbering * used internally by google-java-format. */ private static void parseRangeSet(ImmutableRangeSet.Builder<Integer> result, String ranges) { for (String range : COMMA_SPLITTER.split(ranges)) { result.add(parseRange(range)); } }
/** * Add all ranges from the specified range set to this builder. Adjacent ranges are permitted * and will be merged, but overlapping ranges will cause an exception when {@link #build()} is * called. */ @CanIgnoreReturnValue public Builder<C> addAll(RangeSet<C> ranges) { return addAll(ranges.asRanges()); }
@CanIgnoreReturnValue Builder<C> combine(Builder<C> builder) { addAll(builder.ranges); return this; }
/** Returns a new builder for an immutable range set. */ public static <C extends Comparable<?>> Builder<C> builder() { return new Builder<C>(); }