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.dishevelled.bio.range.rtree.RangeGeometries.java

/**
 * Create and return a new rectangle geometry from the specified closed range <code>[lower..upper]</code>.
 *
 * @param <N> value type// w w w .j ava  2  s.c om
 * @param lower lower endpoint, must not be null
 * @param upper upper endpoint, must not be null
 * @return a new rectangle geometry from the specified closed range
 */
public static <N extends Number & Comparable<? super N>> Rectangle closed(final N lower, final N upper) {
    checkNotNull(lower);
    checkNotNull(upper);
    return range(Range.closed(lower, upper));
}

From source file:net.sf.mzmine.util.components.RangeComponent.java

/**
 * @return Returns the current values/*from  w ww  .j a va  2s .  c  o  m*/
 */
public Range<Double> getRangeValue() {
    double minValue = ((Number) minTxtField.getValue()).doubleValue();
    double maxValue = ((Number) maxTxtField.getValue()).doubleValue();
    return Range.closed(minValue, maxValue);
}

From source file:org.mskcc.juber.intervals.IntervalNameMap.java

public List<String> getIntersecting(String contig, int start, int end) {
    List<String> nameList = new ArrayList<String>();
    Range<Integer> range = Range.closed(start, end);

    // get the contig-specific list of range maps
    List<TreeRangeMap<Integer, String>> contigRanges = contigIntervals.get(contig);

    if (contigRanges == null) {
        return nameList;
    }/*from  w w  w.  j  ava 2s  . com*/

    // check each map in the list for intersection
    for (int i = 0; i < contigRanges.size(); i++) {
        TreeRangeMap<Integer, String> map = contigRanges.get(i);
        Map<Range<Integer>, String> intersecting = map.subRangeMap(range).asMapOfRanges();

        // add all intersecting ranges from the current map to the return
        // list
        for (Range<Integer> key : intersecting.keySet()) {
            nameList.add(intersecting.get(key));
        }
    }

    return nameList;
}

From source file:org.mskcc.shenkers.view.RangeSetIntervalView.java

public void setData(RangeSet<Integer> intervals) {
    for (Range<Integer> interval : intervals.asRanges()) {
        Range<Double> r = Range.closed((interval.lowerEndpoint() - min + 0.) / length,
                (interval.upperEndpoint() - min + 1.) / length);
        logger.info("range {}", r);
        ranges.add(r);//from w  w w  .j a v  a  2s.c o m
    }

    List<Node> content = new ArrayList<>();
    for (Range<Double> interval : ranges.subRangeSet(Range.closed(0., 1.)).asRanges()) {
        Rectangle rectangle = new Rectangle();

        rectangle.widthProperty()
                .bind(widthProperty().multiply(interval.upperEndpoint() - interval.lowerEndpoint()));
        rectangle.heightProperty().bind(heightProperty());
        rectangle.xProperty().bind(widthProperty().multiply(interval.lowerEndpoint()));

        content.add(rectangle);
    }

    getChildren().setAll(content);
}

From source file:org.sonatype.nexus.repository.http.RangeParser.java

/**
 * Returns a list of {@link Range}s, each indicating a range of byte indices (inclusive).
 *
 * Range: bytes=0-10 (from byte 0 to byte 10)
 * Range: bytes=500-999 (from byte 500 to byte 999)
 * Range: bytes=500- (from byte 500 to the end)
 * Range: bytes=-500 (the last 500 bytes, per the RFC)
 *
 * @return {@code null} if the requested range cannot be satisfied given the size of the content, or an empty list in
 * the case of parsing errors/*www  . j  av a2  s.  c  om*/
 */
public List<Range<Long>> parseRangeSpec(final String rangeHeader, long size) {
    Range<Long> content = Range.closed(0L, size - 1L);

    // TODO: Current limitation: only one Range of bytes supported in forms of "-X", "X-Y" (where X<Y) and "X-".
    if (!Strings.isNullOrEmpty(rangeHeader)) {
        try {
            if (rangeHeader.startsWith("bytes=") && rangeHeader.length() > 6 && !rangeHeader.contains(",")) {
                final String rangeSpec = rangeHeader.substring(6, rangeHeader.length());
                if (rangeSpec.startsWith("-")) {
                    final long byteCount = Long.parseLong(rangeSpec.substring(1));
                    if (byteCount > size) {
                        return UNSATISFIABLE;
                    }
                    final Range<Long> suffix = Range.atLeast(size - byteCount);
                    return ensureSatisfiable(suffix, content);
                } else if (rangeSpec.endsWith("-")) {
                    final Range<Long> requested = Range
                            .atLeast(Long.parseLong(rangeSpec.substring(0, rangeSpec.length() - 1)));
                    return ensureSatisfiable(requested, content);
                } else if (rangeSpec.contains("-")) {
                    final String[] parts = rangeSpec.split("-");
                    return ensureSatisfiable(Range.closed(Long.parseLong(parts[0]), Long.parseLong(parts[1])),
                            content);
                } else {
                    log.warn("Malformed HTTP Range value: {}, ignoring it", rangeHeader);
                }
            } else {
                log.warn("Unsupported non-byte or multiple HTTP Ranges: {}; sending complete content",
                        rangeHeader);
            }
        } catch (Exception e) {
            if (log.isDebugEnabled()) {
                log.debug("Problem parsing Range value: {}, ignoring", rangeHeader, e);
            } else {
                log.warn("Problem parsing Range value: {}, ignoring: {}", rangeHeader, e.toString());
            }
        }
    }

    return WHOLE_RANGE;
}

From source file:org.sonatype.nexus.repository.partial.RangeParser.java

/**
 * Returns a list of {@link Range}s, each indicating a range of byte indices (inclusive).
 *
 * Range: bytes=0-10 (from byte 0 to byte 10)
 * Range: bytes=500-999 (from byte 500 to byte 999)
 * Range: bytes=500- (from byte 500 to the end)
 * Range: bytes=-500 (the last 500 bytes, per the RFC)
 *
 * @return {@code null} if the requested range cannot be satisfied given the size of the content, or an empty list in
 * the case of parsing errors/*from   w ww. j  a va2 s .c  o  m*/
 */
public List<Range<Long>> parseRangeSpec(final String rangeHeader, long size) {
    Range content = Range.closed(0L, size - 1L);

    // TODO: Current limitation: only one Range of bytes supported in forms of "-X", "X-Y" (where X<Y) and "X-".
    if (!Strings.isNullOrEmpty(rangeHeader)) {
        try {
            if (rangeHeader.startsWith("bytes=") && rangeHeader.length() > 6 && !rangeHeader.contains(",")) {
                final String rangeSpec = rangeHeader.substring(6, rangeHeader.length());
                if (rangeSpec.startsWith("-")) {
                    final long byteCount = Long.parseLong(rangeSpec.substring(1));
                    if (byteCount > size) {
                        return UNSATISFIABLE;
                    }
                    final Range<Long> suffix = Range.atLeast(size - byteCount);
                    return ensureSatisfiable(suffix, content);
                } else if (rangeSpec.endsWith("-")) {
                    final Range<Long> requested = Range
                            .atLeast(Long.parseLong(rangeSpec.substring(0, rangeSpec.length() - 1)));
                    return ensureSatisfiable(requested, content);
                } else if (rangeSpec.contains("-")) {
                    final String[] parts = rangeSpec.split("-");
                    return ensureSatisfiable(Range.closed(Long.parseLong(parts[0]), Long.parseLong(parts[1])),
                            content);
                } else {
                    log.warn("Malformed HTTP Range value: {}, ignoring it", rangeHeader);
                }
            } else {
                log.warn(
                        "Nexus does not support non-byte or multiple HTTP Ranges, sending complete content: Range value {}",
                        rangeHeader);
            }
        } catch (Exception e) {
            if (log.isDebugEnabled()) {
                log.debug("Problem parsing Range value: {}, ignoring it", rangeHeader, e);
            } else {
                log.info("Problem parsing Range value: {}, ignoring it", rangeHeader);
            }
        }
    }

    return WHOLE_RANGE;
}

From source file:net.sf.mzmine.parameters.parametertypes.tolerances.MZTolerance.java

public Range<Double> getToleranceRange(final double mzValue) {
    final double absoluteTolerance = getMzToleranceForMass(mzValue);
    return Range.closed(mzValue - absoluteTolerance, mzValue + absoluteTolerance);
}

From source file:org.robotframework.ide.eclipse.main.plugin.project.build.validation.MockReporter.java

@Override
public void handleProblem(final RobotProblem problem, final IFile file, final RobotToken token) {
    final ProblemPosition position = new ProblemPosition(token.getLineNumber(),
            Range.closed(token.getStartOffset(), token.getStartOffset() + token.getText().length()));
    handleProblem(problem, file, position, new HashMap<String, Object>());
}

From source file:org.apache.aurora.scheduler.base.Numbers.java

/**
 * Converts a set of integers into a set of contiguous closed ranges that equally represent the
 * input integers.//from w w  w. j a v  a 2s. c o  m
 * <p>
 * The resulting ranges will be in ascending order.
 * <p>
 * TODO(wfarner): Change this to return a canonicalized RangeSet.
 *
 * @param values Values to transform to ranges.
 * @return Closed ranges with identical members to the input set.
 */
public static Set<Range<Integer>> toRanges(Iterable<Integer> values) {
    ImmutableSet.Builder<Range<Integer>> builder = ImmutableSet.builder();

    PeekingIterator<Integer> iterator = Iterators.peekingIterator(Sets.newTreeSet(values).iterator());

    // Build ranges until there are no numbers left.
    while (iterator.hasNext()) {
        // Start a new range.
        int start = iterator.next();
        int end = start;
        // Increment the end until the range is non-contiguous.
        while (iterator.hasNext() && iterator.peek() == end + 1) {
            end++;
            iterator.next();
        }

        builder.add(Range.closed(start, end));
    }

    return builder.build();
}

From source file:org.mskcc.shenkers.view.GeneViewBuilder.java

public T getView(int start, int end) {
    GenericIntervalView<T> giv = new GenericIntervalView<>(gene.lowerEndpoint(), gene.upperEndpoint());
    List<Pair<Integer, Integer>> ranges = new ArrayList<>();
    List<T> panes = new ArrayList<>();

    for (Range<Integer> r : codingSubset.subRangeSet(Range.closed(start, end)).asRanges()) {
        ranges.add(new Pair<>(r.lowerEndpoint(), r.upperEndpoint()));

        panes.add((T) new GenePartIntervalNode<T>(1., (T) new RectangleIntervalNode()));
    }/*  w  w w. java2 s.c om*/
    for (Range<Integer> r : untranslated.subRangeSet(Range.closed(start, end)).asRanges()) {
        ranges.add(new Pair<>(r.lowerEndpoint(), r.upperEndpoint()));
        panes.add((T) new GenePartIntervalNode<T>(.5, (T) new RectangleIntervalNode()));
    }
    for (Range<Integer> r : introns.subRangeSet(Range.closed(start, end)).asRanges()) {
        ranges.add(new Pair<>(r.lowerEndpoint(), r.upperEndpoint()));
        panes.add((T) new GenePartIntervalNode<T>(.1, (T) new RectangleIntervalNode()));
    }
    giv.setData(ranges, panes);
    return (T) giv;
}