/** * Returns a new range set consisting of the difference of this range set and {@code other}. * * <p>This is essentially the same as {@code TreeRangeSet.create(this).removeAll(other)} except it * returns an {@code ImmutableRangeSet}. * * @since 21.0 */ public ImmutableRangeSet<C> difference(RangeSet<C> other) { RangeSet<C> copy = TreeRangeSet.create(this); copy.removeAll(other); return copyOf(copy); }
/** * 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); }
/** * Returns a new range set consisting of the difference of this range set and {@code other}. * * <p>This is essentially the same as {@code TreeRangeSet.create(this).removeAll(other)} except it * returns an {@code ImmutableRangeSet}. * * @since 21.0 */ public ImmutableRangeSet<C> difference(RangeSet<C> other) { RangeSet<C> copy = TreeRangeSet.create(this); copy.removeAll(other); return copyOf(copy); }
/** * Returns a new range set consisting of the difference of this range set and {@code other}. * * <p>This is essentially the same as {@code TreeRangeSet.create(this).removeAll(other)} except it * returns an {@code ImmutableRangeSet}. * * @since 21.0 */ public ImmutableRangeSet<C> difference(RangeSet<C> other) { RangeSet<C> copy = TreeRangeSet.create(this); copy.removeAll(other); 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; }
@Override public RangeSet<String> getDimensionRangeSet(String dimension) { RangeSet<String> retSet = null; for (DimFilter field : fields) { RangeSet<String> rangeSet = field.getDimensionRangeSet(dimension); if (rangeSet != null) { if (retSet == null) { retSet = TreeRangeSet.create(rangeSet); } else { retSet.removeAll(rangeSet.complement()); } } } return retSet; }
/** * 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); }
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(); }
@Override public Filtration apply(final Filtration filtration) { if (filtration.getDimFilter() == null) { return filtration; } // Convert existing filtration intervals to a RangeSet. final RangeSet<Long> rangeSet = RangeSets.fromIntervals(filtration.getIntervals()); // Remove anything outside eternity. rangeSet.removeAll(RangeSets.fromIntervals(ImmutableList.of(Filtration.eternity())).complement()); // Extract time bounds from the dimFilter. final Pair<DimFilter, RangeSet<Long>> pair = extractConvertibleTimeBounds(filtration.getDimFilter()); if (pair.rhs != null) { rangeSet.removeAll(pair.rhs.complement()); } return Filtration.create(pair.lhs, RangeSets.toIntervals(rangeSet)); }
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 } }
private void remove(IpRangeSet exclude) { rangeSet.removeAll(exclude.rangeSet); }
/** * Removes the given set of intervals * @param toRemove intervals to remove */ public void remove(IntervalBed toRemove) { intervals.removeAll(toRemove.intervals.asRanges()); } public void write(File bed, String name) throws IOException {
/** Returns a new {@link IntegerSpace} */ public IntegerSpace build() { RangeSet<Integer> rangeSet = TreeRangeSet.create(_including); rangeSet.removeAll(_excluding); return new IntegerSpace(rangeSet); }
/** * Returns a new range set consisting of the difference of this range set and {@code other}. * * <p>This is essentially the same as {@code TreeRangeSet.create(this).removeAll(other)} except it * returns an {@code ImmutableRangeSet}. * * @since 21.0 */ public ImmutableRangeSet<C> difference(RangeSet<C> other) { RangeSet<C> copy = TreeRangeSet.create(this); copy.removeAll(other); return copyOf(copy); }
@Override public void setDriver(LensDriver driver) { super.setDriver(driver); Class<? extends Parser<T>> parserClass = (Class<? extends Parser<T>>) driver.getConf().getClass(QUERY_COST_PARSER, DEFAULT_QUERY_COST_PARSER, Parser.class); try { this.parser = parserClass.newInstance(); } catch (InstantiationException | IllegalAccessException e) { throw new IllegalArgumentException("Couldn't initialize query cost parser from class " + parserClass); } allowedCosts = parseAllowedRangeSet(driver.getConf().get(ALLOWED_RANGE_SETS)); allowedCosts.removeAll(parseDisallowedRangeSet(driver.getConf().get(DISALLOWED_RANGE_SETS))); }
private RangeSet<RowKeyWrapper> narrowRange(RangeSet<RowKeyWrapper> rangeSet, Filter filter) { if (filter == null) { return rangeSet; } RangeSet<RowKeyWrapper> filterRangeSet = filterAdapter.getIndexScanHint(filter); if (filterRangeSet.encloses(Range.<RowKeyWrapper>all())) { return rangeSet; } rangeSet.removeAll(filterRangeSet.complement()); return rangeSet; }
private RowSet narrowRowSet(RowSet rowSet, Filter filter) { if (filter == null) { return rowSet; } RangeSet<RowKeyWrapper> filterRangeSet = filterAdapter.getIndexScanHint(filter); if (filterRangeSet.encloses(Range.<RowKeyWrapper>all())) { return rowSet; } RangeSet<RowKeyWrapper> scanRangeSet = rowRangeAdapter.rowSetToRangeSet(rowSet); // intersection of scan ranges & filter ranges scanRangeSet.removeAll(filterRangeSet.complement()); return rowRangeAdapter.rangeSetToRowSet(scanRangeSet); }
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(); }