/** * 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; }
@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; }
public static void testInvariants(RangeSet<?> rangeSet) { testInvariantsInternal(rangeSet); testInvariantsInternal(rangeSet.complement()); }
/** * 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); }
@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)); }
/** * There are some special cases involving null that require special casing for And and Or instead of simply taking * the complement * * Example 1 : "NOT ( [0,INF) OR null)" The inside of NOT would evaluate to null, and the complement would also * be null. However, by breaking the NOT, this statement is "NOT([0,INF)) AND NOT(null)", which means it should * actually evaluate to (-INF, 0). * * Example 2 : "NOT ( [0,INF) AND null )" The inside of NOT would evaluate to [0,INF), and the complement would be * (-INF, 0). However the statement is actually "NOT([0,INF)) OR NOT(null)", and it should be evaluated to null. */ @Override public RangeSet<String> getDimensionRangeSet(String dimension) { if (field instanceof AndDimFilter) { List<DimFilter> fields = ((AndDimFilter) field).getFields(); return new OrDimFilter(Lists.transform(fields, NotDimFilter::new)).getDimensionRangeSet(dimension); } if (field instanceof OrDimFilter) { List<DimFilter> fields = ((OrDimFilter) field).getFields(); return new AndDimFilter(Lists.transform(fields, NotDimFilter::new)).getDimensionRangeSet(dimension); } if (field instanceof NotDimFilter) { return ((NotDimFilter) field).getField().getDimensionRangeSet(dimension); } RangeSet<String> rangeSet = field.getDimensionRangeSet(dimension); return rangeSet == null ? null : rangeSet.complement(); }
final Pair<DimFilter, RangeSet<Long>> pair = extractConvertibleTimeBounds(child); if (pair.rhs != null && pair.lhs == null) { return Pair.of(null, pair.rhs.complement()); } else { return Pair.of(filter, null);
public void testComplementOfSubRangeSet() { for (Range<Integer> range1 : QUERY_RANGES) { for (Range<Integer> range2 : QUERY_RANGES) { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(range1); rangeSet.add(range2); for (Range<Integer> subRange : QUERY_RANGES) { testViewAgainstExpected( expectedComplement(expectedSubRangeSet(rangeSet, subRange)), rangeSet.subRangeSet(subRange).complement()); } } } }
assertEquals(mutable, built); assertEquals(ImmutableRangeSet.copyOf(mutable), built); assertEquals(mutable.complement(), built.complement());
public static RangeSet<CharacterPosition> intersection(RangeSet<CharacterPosition> r1, RangeSet<CharacterPosition> r2) { RangeSet<CharacterPosition> inverse = TreeRangeSet.create(r1.complement()); inverse.addAll(r2.complement()); return inverse.complement(); }
public void updateInsertionMarkerIndex(int index) { if (this.insertionMarkerIndex != index) { this.insertionMarkerIndex = index; } com.google.common.collect.RangeSet<Integer> rs = TreeRangeSet.create(); updateNodesNow(rs.complement()); }
/** Take the complement of this space, bounded by some other {@link IntegerSpace} */ public IntegerSpace not(IntegerSpace within) { return new IntegerSpace(_rangeset.complement()).intersection(within); }
/** * 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 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); }
/** * Take the complement of this space, bounded by existing lower and upper limits of the space. * This can be used as a way to represent a set of excluded ranges as a positive space. */ public IntegerSpace not() { if (_rangeset.isEmpty()) { return EMPTY; } return new IntegerSpace(_rangeset.complement().subRangeSet(_rangeset.span())); }
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; }
public static void testInvariants(RangeSet<?> rangeSet) { testInvariantsInternal(rangeSet); testInvariantsInternal(rangeSet.complement()); }
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); }
public void testComplementOfSubRangeSet() { for (Range<Integer> range1 : QUERY_RANGES) { for (Range<Integer> range2 : QUERY_RANGES) { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(range1); rangeSet.add(range2); for (Range<Integer> subRange : QUERY_RANGES) { testViewAgainstExpected( expectedComplement(expectedSubRangeSet(rangeSet, subRange)), rangeSet.subRangeSet(subRange).complement()); } } } }