Example usage for com.google.common.collect RangeMap asMapOfRanges

Usage

From source file:org.mskcc.shenkers.data.interval.RangeTools.java

public static <T> RangeMap<Integer, T> asClosed(RangeMap<Integer, T> s) {
    RangeMap<Integer, T> closedIntervalSet = TreeRangeMap.create();
    Map<Range<Integer>, T> map = s.asMapOfRanges();
    for (Map.Entry<Range<Integer>, T> r : map.entrySet()) {
        closedIntervalSet.put(asClosed(r.getKey()), r.getValue());
    }//from  w w w. j  av a2s . c  om
    return closedIntervalSet;
}

From source file:eu.trentorise.opendata.semtext.SemText.java

/**
 * Returns the terms enclosed by enclosingSpan as a new TreeRangeMap.
 *//*w ww  . jav  a2 s.co  m*/
private static TreeRangeMap<Integer, Term> enclosingNewTerms(Span enclosingSpan,
        RangeMap<Integer, Term> termRanges) {
    TreeRangeMap<Integer, Term> ret = TreeRangeMap.create();

    Range enclosingRange = spanToRange(enclosingSpan);

    RangeMap<Integer, Term> subRangeMap = termRanges.subRangeMap(enclosingRange);

    for (Map.Entry<Range<Integer>, Term> termEntry : subRangeMap.asMapOfRanges().entrySet()) {
        if (enclosingRange.encloses(spanToRange(termEntry.getValue()))) {
            ret.put(termEntry.getKey(), termEntry.getValue());
        }
    }

    return ret;
}

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

/** Applies the replacements to the given source, and re-format any edited javadoc. */
private static String applyReplacements(String source, RangeMap<Integer, String> replacements) {
    // save non-empty fixed ranges for reformatting after fixes are applied
    RangeSet<Integer> fixedRanges = TreeRangeSet.create();

    // Apply the fixes in increasing order, adjusting ranges to account for
    // earlier fixes that change the length of the source. The output ranges are
    // needed so we can reformat fixed regions, otherwise the fixes could just
    // be applied in descending order without adjusting offsets.
    StringBuilder sb = new StringBuilder(source);
    int offset = 0;
    for (Map.Entry<Range<Integer>, String> replacement : replacements.asMapOfRanges().entrySet()) {
        Range<Integer> range = replacement.getKey();
        String replaceWith = replacement.getValue();
        int start = offset + range.lowerEndpoint();
        int end = offset + range.upperEndpoint();
        sb.replace(start, end, replaceWith);
        if (!replaceWith.isEmpty()) {
            fixedRanges.add(Range.closedOpen(start, end));
        }//from   w w  w  .j a v  a2s  .  co  m
        offset += replaceWith.length() - (range.upperEndpoint() - range.lowerEndpoint());
    }
    String result = sb.toString();

    // If there were any non-empty replaced ranges (e.g. javadoc), reformat the fixed regions.
    // We could avoid formatting twice in --fix-imports=also mode, but that is not the default
    // and removing imports won't usually affect javadoc.
    if (!fixedRanges.isEmpty()) {
        try {
            result = new Formatter().formatSource(result, fixedRanges.asRanges());
        } catch (FormatterException e) {
            // javadoc reformatting is best-effort
        }
    }
    return result;
}

From source file:org.mskcc.shenkers.data.interval.DiscreteRangeMap.java

public RangeMap<Double, Double> toReal(RangeMap<Integer, Double> rm) {
    RangeMap<Double, Double> ram = TreeRangeMap.create();

    rm.asMapOfRanges().forEach((range, val) -> ram.put(asReal(range), val));
    return ram;//from www .  j a  v  a  2s.  co m
}

From source file:com.basistech.tclre.RuntimeColorMap.java

private void computeBmp(RangeMap<Integer, Short> fullMap) {
    for (Map.Entry<Range<Integer>, Short> me : fullMap.asMapOfRanges().entrySet()) {
        Range<Integer> range = me.getKey();
        int min = range.lowerEndpoint();
        if (range.lowerBoundType() == BoundType.OPEN) {
            min++;/*from   ww w .ja v  a 2 s.c  o  m*/
        }
        if (min < Character.MAX_VALUE) {
            int rmax = range.upperEndpoint();
            if (range.upperBoundType() == BoundType.OPEN) {
                rmax--;
            }
            int max = Math.min(Character.MAX_VALUE, rmax);
            for (int x = min; x <= max; x++) {
                this.bmpMap[x] = me.getValue();
            }
        }
    }
}

From source file:guru.qas.martini.gherkin.DefaultMixology.java

protected List<Recipe> getRecipes(FeatureWrapper feature, Collection<Pickle> pickles) {
    Map<Integer, Recipe> recipeIndex = new LinkedHashMap<>();

    RangeMap<Integer, ScenarioDefinition> rangeMap = getRangeMap(feature);
    for (Pickle pickle : pickles) {
        List<PickleLocation> locations = pickle.getLocations();
        Map<Integer, PickleLocation> locationIndex = new HashMap<>();
        locations.forEach(l -> {//from   w  w w. ja  v  a 2  s. c  o  m
            int line = l.getLine();
            locationIndex.put(line, l);
        });

        Integer line = Ordering.natural().max(locationIndex.keySet());
        recipeIndex.computeIfAbsent(line, l -> {
            PickleLocation location = locationIndex.get(l);
            Range<Integer> range = Range.singleton(line);
            RangeMap<Integer, ScenarioDefinition> subRangeMap = rangeMap.subRangeMap(range);
            Map<Range<Integer>, ScenarioDefinition> asMap = subRangeMap.asMapOfRanges();
            checkState(1 == asMap.size(), "no single range found encompassing PickleLocation %s", location);
            ScenarioDefinition definition = Iterables.getOnlyElement(asMap.values());
            return new DefaultRecipe(feature, pickle, location, definition);
        });
    }
    return ImmutableList.copyOf(recipeIndex.values());
}

From source file:org.mskcc.shenkers.data.interval.DiscreteRangeMap.java

public void testGetGraphic() {
    RangeMap<Integer, Double> ram = TreeRangeMap.create();
    //        ram.put(Range.closed(0, 4), 0.);
    System.out.println("adding");
    ram = add(ram, Range.closed(1, 3), 1.);
    ram.asMapOfRanges().forEach((r, d) -> System.out.println(String.format("%s %f", r, d)));
    System.out.println("adding");
    ram = add(ram, Range.closed(-1, 4), 1.);
    ram.asMapOfRanges().forEach((r, d) -> System.out.println(String.format("%s %f", r, d)));
    System.out.println("adding");
    ram = add(ram, Range.closed(3, 5), 2.);
    ram.asMapOfRanges().forEach((r, d) -> System.out.println(String.format("%s %f", r, d)));
    System.out.println("asReal");
    ram.asMapOfRanges().forEach((r, d) -> System.out.println(String.format("%s %f", r, d)));
    toReal(ram).asMapOfRanges().forEach((r, d) -> System.out.println(String.format("%s %f", r, d)));

    RangeMap<Double, Double> toReal = toReal(ram);
    System.out.println("span " + toReal.span());
    double length = length(toReal.span());
    System.out.println("length " + length);
    int k = 7;//from www .j a v a  2  s  .  co  m
    double binSize = length / k;
    Double lb = toReal.span().lowerEndpoint();
    for (int i = 0; i < k; i++) {
        Range<Double> closedOpen = Range.closedOpen(lb + (i * 1. / k * length), lb + ((i + 1.) / k * length));
        System.out.println("bin " + i);
        System.out.println(closedOpen);
        Double max = Collections.max(toReal.subRangeMap(closedOpen).asMapOfRanges().values());
        Double mean = toReal.subRangeMap(closedOpen).asMapOfRanges().values().stream()
                .mapToDouble(Double::doubleValue).average().orElse(0.);

        //            StreamSupport.doubleStream(new Spliterator.OfDouble()
        //                    false);
        System.out.println("max " + max);
        System.out.println("mean " + mean);
    }

}

From source file:radsoft.syntaxhighlighter.SyntaxHighlighter.java

public Map<Range<Integer>, String> parse(CharSequence content, int allstart, int allend) {
    if (content == null)
        throw new NullPointerException("argument 'content' cannot be null");

    RangeMap<Integer, String> matches = TreeRangeMap.create();
    parse1(matches, brush, content, allstart, allend);
    return matches.asMapOfRanges();
}

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

public void setData(Range<Integer> view, RangeMap<Integer, Double> data) {

    int lb = view.lowerEndpoint();
    int ub = view.upperEndpoint();
    int r = ub - lb + 1;
    Map<Range<Integer>, Double> map = data.asMapOfRanges();

    if (listBinding != null) {
        listBinding.removeListener(pointUpdater);
    }/*from w  w w.  j  av  a2s.  c o  m*/
    listBinding = Bindings.createObjectBinding(() -> {

        double width = graphic.widthProperty().get();
        double height = graphic.heightProperty().get();
        double min = minProperty.get();
        double max = maxProperty.get();
        boolean flipDomain = flipDomainProperty.get();
        boolean flipRange = flipRangeProperty.get();

        List<Double> points = map.entrySet().stream().flatMap(entry -> {

            Double value = scaleValue(entry.getValue(), min, max, height, flipRange);
            double[] d = scaleDomain(entry.getKey(), lb, r, width, flipDomain);
            return Stream.of(d[0], value, d[1], value);
        }).collect(Collectors.toList());
        points.addAll(0,
                Arrays.asList(points.get(0), scaleValue(zero.doubleValue(), min, max, height, flipRange)));
        points.addAll(Arrays.asList(points.get(points.size() - 2),
                scaleValue(zero.doubleValue(), min, max, height, flipRange)));

        return points;
    }, graphic.widthProperty(), graphic.heightProperty(), minProperty, maxProperty, flipRangeProperty,
            flipDomainProperty, zero);

    listBinding.addListener(pointUpdater);

    graphic.getChildren().add(p);
}

From source file:eu.trentorise.opendata.semtext.SemText.java

/**
 * Returns a new semantic text having existing terms plus the provided ones.
 * If new terms overlaps with other ones, existing overlapping terms are
 * removed. If a term is precisely overlapping an existing one, resulting
 * term will have the selected meaning and meaning status of the provided
 * term and the list of meanings will be a merge of the meanings found in
 * the provided term plus the meanings of the existing term.
 *
 * Terms to merge which are outside of existing sentences will be ignored.
 *///  ww  w. j a v a 2  s.co m
// note: Current version is based on RangeMaps thus quite inefficient
public SemText merge(Iterable<Term> termsToMerge) {

    SemTexts.checkSpans(termsToMerge, 0, text.length(), "Invalid spans for terms to merge!");

    if (sentences.size() > 1) {
        LOG.log(Level.WARNING,
                "Found more than one sentence while mergin terms into SemText {0}, output semtext will have only one sentence covering the whole text.",
                this.text);
    }

    ImmutableList.Builder<Sentence> newSentenceB = ImmutableList.builder();

    RangeMap<Integer, Term> termToMergeRanges = TreeRangeMap.create();

    for (Term termToMerge : termsToMerge) {
        termToMergeRanges.put(spanToRange(termToMerge), termToMerge);
    }

    for (Sentence sentence : sentences) {

        RangeMap<Integer, Term> mergeRanges = enclosingNewTerms(sentence, termToMergeRanges);
        Map<Range<Integer>, Term> mergeRangesMap = mergeRanges.asMapOfRanges();

        for (Term origTerm : sentence.getTerms()) {
            Term newTerm = mergeRangesMap.get(spanToRange(origTerm));

            if (newTerm == null) { // orig term doesn't coincide with new term
                if (mergeRanges.subRangeMap(spanToRange(origTerm)).asMapOfRanges().isEmpty()) {
                    // origTerm does not overlap with new terms, add it                                                    
                    mergeRanges.put(spanToRange(origTerm), origTerm);
                }
            } else { // orig term coincides with new term, merge it
                mergeRanges.put(spanToRange(newTerm),
                        newTerm.with(Iterables.concat(newTerm.getMeanings(), origTerm.getMeanings())));
            }

        }

        newSentenceB.add(sentence.withTerms(mergeRangesMap.values()));

    }
    return withSentences(newSentenceB.build());
}

• «
• 1
• 2
• »