Example usage for com.google.common.collect Range closed

List of usage examples for com.google.common.collect Range closed

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.collect.*
  5. Range
  6. closed

Introduction

In this page you can find the example usage for com.google.common.collect Range closed.

Prototype

public static <C extends Comparable<?>> Range<C> closed(C lower, C upper)

Source Link

Document

Returns a range that contains all values greater than or equal to lower and less than or equal to upper .

Usage

From source file:org.robotframework.ide.eclipse.main.plugin.tableeditor.source.DocumentUtilities.java

public static Optional<IRegion> findLiveVariable(final String cellContent, final int offset) {
    final Matcher matcher = Pattern.compile("[@$&%][^@$%&]*").matcher(cellContent);
    while (matcher.find()) {
        final int start = matcher.start();
        final int closingBracketIndex = cellContent.indexOf('}', start + 1);
        final int end = closingBracketIndex == -1 ? matcher.end()
                : Math.min(matcher.end(), closingBracketIndex);
        if (Range.closed(start, end).contains(offset)) {
            return Optional.<IRegion>of(new Region(start, end - start));
        }/*from  w  ww. j a v a  2  s  . c  om*/
    }
    return Optional.empty();
}

From source file:com.asoroka.sidora.tabularmetadata.heuristics.ranges.RunningMinMaxHeuristic.java

private Function<DataType, Range<?>> getRangeForType() {
    return new Function<DataType, Range<?>>() {

        @Override//  www  . ja  va2 s  .  c  om
        public Range<?> apply(final DataType type) {
            final boolean hasMin = minimums.containsKey(type);
            final boolean hasMax = maximums.containsKey(type);
            final Comparable<?> min = minimums.get(type);
            final Comparable<?> max = maximums.get(type);
            if (hasMin) {
                if (hasMax) {
                    return Range.closed(min, max);
                }
                return atLeast(min);
            }
            if (hasMax) {
                return atMost(max);
            }
            return Range.all();
        }
    };
}

From source file:org.robotframework.ide.eclipse.main.plugin.model.RobotSuiteFileSection.java

@Override
public Optional<? extends RobotElement> findElement(final int offset) {
    for (final RobotFileInternalElement element : getChildren()) {
        final Optional<? extends RobotElement> candidate = element.findElement(offset);
        if (candidate.isPresent()) {
            return candidate;
        }/*from   ww w.  ja v a 2  s.c o  m*/
    }
    for (final TableHeader<? extends ARobotSectionTable> header : sectionTable.getHeaders()) {
        if (Range.closed(header.getBeginPosition().getOffset(), header.getEndPosition().getOffset())
                .contains(offset)) {
            return Optional.of(this);
        }
    }
    return Optional.empty();
}

From source file:net.sf.mzmine.parameters.parametertypes.ranges.DoubleRangeParameter.java

@Override
public void loadValueFromXML(Element xmlElement) {
    NodeList minNodes = xmlElement.getElementsByTagName("min");
    if (minNodes.getLength() != 1)
        return;/*from   w  w w. j a v  a  2  s  . c  om*/
    NodeList maxNodes = xmlElement.getElementsByTagName("max");
    if (maxNodes.getLength() != 1)
        return;
    String minText = minNodes.item(0).getTextContent();
    String maxText = maxNodes.item(0).getTextContent();
    double min = Double.valueOf(minText);
    double max = Double.valueOf(maxText);
    value = Range.closed(min, max);
}

From source file:com.wandrell.tabletop.interval.DefaultInterval.java

/**
 * Sets the interval's lower limit./*from   w w w.  ja v  a  2  s .  c  o m*/
 * 
 * @param lowerLimit
 *            the lower limit
 */
public final void setLowerLimit(final Integer lowerLimit) {
    checkNotNull(lowerLimit, "Received a null pointer as lower limit");

    range = Range.closed(lowerLimit, range.upperEndpoint());
}

From source file:org.geogig.osm.internal.history.HistoryDownloader.java

public void downloadAll(ProgressListener progressListener) {
    RemoteChangesetDownloader downloader = (RemoteChangesetDownloader) this.downloader;
    Range<Long> range = Range.closed(initialChangeset, finalChangeset);
    ContiguousSet<Long> changesetIds = ContiguousSet.create(range, DiscreteDomain.longs());

    progressListener/*from w  w  w  .j  a  v a  2s .c  o  m*/
            .setDescription("Downloading changesets " + initialChangeset + " to " + finalChangeset + "...");

    final int readTimeoutMinutes = 20;

    final AtomicBoolean abortFlag = new AtomicBoolean();

    List<Future<Long>> futures = new LinkedList<>();
    for (Long changesetId : changesetIds) {
        try {

            Future<Long> future = downloader.download(changesetId, readTimeoutMinutes, abortFlag);
            futures.add(future);
        } catch (IOException e) {
            e.printStackTrace();
            throw Throwables.propagate(e);
        }
    }
    for (Future<Long> f : futures) {
        try {
            Long id = f.get();
            if (-1L == id.longValue()) {
                continue;
            }
            progressListener.setDescription("Downloaded changeset " + id + ".");
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
            throw Throwables.propagate(e);
        }
    }
    progressListener.setDescription("Done!");
}

From source file:org.apache.kylin.common.util.RangeUtil.java

/**
 * remove from self the elements that exist in other
 * @return/*ww w. j ava 2s. c  o  m*/
 */
public static <C extends Comparable<?>> List<Range<C>> remove(Range<C> self, Range<C> other) {

    // mimic the following logic in guava 18:
    //        RangeSet<C> rangeSet = TreeRangeSet.create();
    //        rangeSet.add(self);
    //        rangeSet.remove(other);
    //        return Lists.newArrayList(rangeSet.asRanges());

    if (other == null || !self.isConnected(other)) {
        return Collections.singletonList(self);
    }

    Range<C> share = self.intersection(other);
    if (share.isEmpty()) {
        return Collections.singletonList(self);
    }

    List<Range<C>> ret = Lists.newArrayList();

    //see left part
    if (!self.hasLowerBound()) {
        if (share.hasLowerBound()) {
            if (share.lowerBoundType() == BoundType.CLOSED) {
                ret.add(Range.lessThan(share.lowerEndpoint()));
            } else {
                ret.add(Range.atMost(share.lowerEndpoint()));
            }
        }
    } else {
        if (self.lowerEndpoint() != share.lowerEndpoint()) {
            if (self.lowerBoundType() == BoundType.CLOSED) {
                if (share.lowerBoundType() == BoundType.CLOSED) {
                    ret.add(Range.closedOpen(self.lowerEndpoint(), share.lowerEndpoint()));
                } else {
                    ret.add(Range.closed(self.lowerEndpoint(), share.lowerEndpoint()));
                }
            } else {
                if (share.lowerBoundType() == BoundType.CLOSED) {
                    ret.add(Range.open(self.lowerEndpoint(), share.lowerEndpoint()));
                } else {
                    ret.add(Range.openClosed(self.lowerEndpoint(), share.lowerEndpoint()));
                }
            }
        } else {
            if (self.lowerBoundType() == BoundType.CLOSED && share.lowerBoundType() == BoundType.OPEN) {
                ret.add(Range.closed(self.lowerEndpoint(), share.lowerEndpoint()));
            }
        }
    }

    //see right part 
    if (!self.hasUpperBound()) {
        if (share.hasUpperBound()) {
            if (share.upperBoundType() == BoundType.CLOSED) {
                ret.add(Range.greaterThan(share.upperEndpoint()));
            } else {
                ret.add(Range.atLeast(share.upperEndpoint()));
            }
        }
    } else {
        if (self.upperEndpoint() != share.upperEndpoint()) {
            if (self.upperBoundType() == BoundType.CLOSED) {
                if (share.upperBoundType() == BoundType.CLOSED) {
                    ret.add(Range.openClosed(share.upperEndpoint(), self.upperEndpoint()));
                } else {
                    ret.add(Range.closed(share.upperEndpoint(), self.upperEndpoint()));
                }
            } else {
                if (share.upperBoundType() == BoundType.CLOSED) {
                    ret.add(Range.open(share.upperEndpoint(), self.upperEndpoint()));
                } else {
                    ret.add(Range.closedOpen(share.upperEndpoint(), self.upperEndpoint()));
                }
            }
        } else {
            if (self.upperBoundType() == BoundType.CLOSED && share.upperBoundType() == BoundType.OPEN) {
                ret.add(Range.closed(self.upperEndpoint(), share.upperEndpoint()));
            }
        }
    }

    return ret;

}

From source file:io.horizondb.model.core.predicates.InPredicate.java

/**    
 * {@inheritDoc}/* w  w w.j a  va2s  .  co m*/
 */
@Override
public RangeSet<Field> getTimestampRanges() {

    if (!isTimestamp()) {
        return TimestampField.ALL;
    }

    ImmutableRangeSet.Builder<Field> builder = ImmutableRangeSet.builder();

    for (Field field : this.values) {

        builder.add(Range.closed(field, field));
    }

    RangeSet<Field> rangeSet = builder.build();

    if (this.notIn) {
        return rangeSet.complement();
    }

    return rangeSet;
}

From source file:org.pascani.dsl.lib.events.TimeLapseEvent.java

/**
 * Checks whether this {@link TimeLapseEvent} object was finished measuring
 * within a given time window, i.e., {@code this.end} is contained in [
 * {@code start} , {@code end}]./*from w  w  w. j a va 2s .  c o m*/
 * 
 * @param start
 *            The initial timestamp of the time window
 * @param end
 *            The final timestamp of the time window
 * @return {@code true} if the range [{@code start}, {@code end}] contains
 *         the final timestamp {@code this} object
 */
@Override
public boolean isInTimeWindow(final long start, final long end) {
    return Range.closed(start, end).contains(this.end);
}

From source file:com.google.googlejavaformat.java.JavaOutput.java

@Override
public void markForPartialFormat(Token start, Token end) {
    int lo = JavaOutput.startTok(start).getIndex();
    int hi = JavaOutput.endTok(end).getIndex();
    partialFormatRanges.add(Range.closed(lo, hi));
}