@Override Range<Integer> computeRange() { return Range.singleton(tok.getIndex()).canonical(INTEGERS); }
return ImmutableSortedSet.of(); Range<C> span = span().canonical(domain); if (!span.hasLowerBound()) {
@Override Range<Integer> computeRange() { return Range.singleton(token.getTok().getIndex()).canonical(INTEGERS); }
return ImmutableSortedSet.of(); Range<C> span = span().canonical(domain); if (!span.hasLowerBound()) {
private static Range<Integer> union(Range<Integer> x, Range<Integer> y) { return x.isEmpty() ? y : y.isEmpty() ? x : x.span(y).canonical(INTEGERS); }
/** * Given an {@code InputOutput}, compute the map from tok indices to line ranges. * * @param put the {@code InputOutput} * @return the map from {@code com.google.googlejavaformat.java.JavaInput.Tok} indices to line * ranges in this {@code put} */ public static Map<Integer, Range<Integer>> makeKToIJ(InputOutput put) { Map<Integer, Range<Integer>> map = new HashMap<>(); int ijN = put.getLineCount(); for (int ij = 0; ij <= ijN; ij++) { Range<Integer> range = put.getRanges(ij).canonical(INTEGERS); for (int k = range.lowerEndpoint(); k < range.upperEndpoint(); k++) { if (map.containsKey(k)) { map.put(k, Range.closedOpen(map.get(k).lowerEndpoint(), ij + 1)); } else { map.put(k, Range.closedOpen(ij, ij + 1)); } } } return map; }
private static Range<Integer> offsetRange(Range<Integer> range, int offset) { range = range.canonical(DiscreteDomain.integers()); return Range.closedOpen(range.lowerEndpoint() + offset, range.upperEndpoint() + offset); }
public void testCanonical_unboundedDomain() { assertEquals(Range.lessThan(0), Range.lessThan(0).canonical(UNBOUNDED_DOMAIN)); assertEquals(Range.lessThan(1), Range.atMost(0).canonical(UNBOUNDED_DOMAIN)); assertEquals(Range.atLeast(0), Range.atLeast(0).canonical(UNBOUNDED_DOMAIN)); assertEquals(Range.atLeast(1), Range.greaterThan(0).canonical(UNBOUNDED_DOMAIN)); assertEquals(Range.all(), Range.<Integer>all().canonical(UNBOUNDED_DOMAIN)); }
private static Range<Integer> union(Range<Integer> x, Range<Integer> y) { return x.isEmpty() ? y : y.isEmpty() ? x : x.span(y).canonical(DiscreteDomain.integers()); }
public void testCanonical() { assertEquals(Range.closedOpen(1, 5), Range.closed(1, 4).canonical(integers())); assertEquals(Range.closedOpen(1, 5), Range.open(0, 5).canonical(integers())); assertEquals(Range.closedOpen(1, 5), Range.closedOpen(1, 5).canonical(integers())); assertEquals(Range.closedOpen(1, 5), Range.openClosed(0, 4).canonical(integers())); assertEquals( Range.closedOpen(Integer.MIN_VALUE, 0), Range.closedOpen(Integer.MIN_VALUE, 0).canonical(integers())); assertEquals(Range.closedOpen(Integer.MIN_VALUE, 0), Range.lessThan(0).canonical(integers())); assertEquals(Range.closedOpen(Integer.MIN_VALUE, 1), Range.atMost(0).canonical(integers())); assertEquals(Range.atLeast(0), Range.atLeast(0).canonical(integers())); assertEquals(Range.atLeast(1), Range.greaterThan(0).canonical(integers())); assertEquals(Range.atLeast(Integer.MIN_VALUE), Range.<Integer>all().canonical(integers())); }
return ImmutableSortedSet.of(); Range<C> span = span().canonical(domain); if (!span.hasLowerBound()) {
public RangeSet<Integer> characterRangesToTokenRanges(Collection<Range<Integer>> characterRanges) throws FormatterException { RangeSet<Integer> tokenRangeSet = TreeRangeSet.create(); for (Range<Integer> characterRange0 : characterRanges) { Range<Integer> characterRange = characterRange0.canonical(DiscreteDomain.integers()); tokenRangeSet.add( characterRangeToTokenRange( characterRange.lowerEndpoint(), characterRange.upperEndpoint() - characterRange.lowerEndpoint())); } return tokenRangeSet; } }
RangeSet<Integer> iRangeSet = iRangeSet0.subRangeSet(Range.closed(0, javaInput.getkN())); for (Range<Integer> iRange : iRangeSet.asRanges()) { Range<Integer> range = expandToBreakableRegions(iRange.canonical(DiscreteDomain.integers())); if (range.equals(EMPTY_RANGE)) {
private Feature(Builder builder) { Preconditions.checkArgument( !builder.supportedVersionRange.canonical(DiscreteDomain.integers()).isEmpty(), "supportedVersionRange must not be empty"); featureName = builder.featureName; childBindings = builder.childBindings.build(); supportedVersionRange = builder.supportedVersionRange; defaultVersionRange = builder.defaultVersionRange; }
public static Range<Long> normalize(Range<Long> range) { range = RangeUtils.startFromZero(range); Range<Long> result = range.canonical(DiscreteDomain.longs()); return result; }
/** Include a range. The {@link Range} must be a finite range. */ public Builder including(Range<Integer> range) { checkArgument( range.hasLowerBound() && range.hasUpperBound(), "Infinite ranges are not supported"); if (!range.isEmpty()) { _including.add(range.canonical(DiscreteDomain.integers())); } return this; }
/** Include a {@link SubRange} */ public Builder including(SubRange range) { if (!range.isEmpty()) { _including.add( Range.closed(range.getStart(), range.getEnd()).canonical(DiscreteDomain.integers())); } return this; }
/** * Creates a range from a Guava's range. * * @param range Guava's range * @return this range */ public static ClosedOpenRange of(Range<Integer> range) { return new ClosedOpenRange( range.canonical(DiscreteDomain.integers()).lowerEndpoint(), range.canonical(DiscreteDomain.integers()).upperEndpoint()); }
@Override public Flowable<T> apply(Range<Long> range) { Range<Long> validRange = Range.closedOpen(0l, (long)items.size()); Range<Long> effectiveRange = range.intersection(validRange).canonical(DiscreteDomain.longs()); List<T> subList = items.subList(effectiveRange.lowerEndpoint().intValue(), effectiveRange.upperEndpoint().intValue()); Flowable<T> result = Flowable.fromIterable(subList); return result; //return subList.stream(); }
/** * * @param range * @return */ public static long rangeToLimit(Range<Long> range) { range = range == null ? null : range.canonical(DiscreteDomain.longs()); long result = range == null || !range.hasUpperBound() ? Query.NOLIMIT : DiscreteDomain.longs().distance(range.lowerEndpoint(), range.upperEndpoint()); return result; }