List of usage examples for com.google.common.collect RangeSet isEmpty
boolean isEmpty();
From source file:org.mskcc.shenkers.view.StackedIntervalView.java
public void setData(List<Pair<Integer, Integer>> intervals) { Collections.sort(intervals, new Comparator<Pair<Integer, Integer>>() { @Override// ww w .j ava 2s. c om public int compare(Pair<Integer, Integer> o1, Pair<Integer, Integer> o2) { return o1.getKey() - o2.getKey(); } }); // Pair<Integer, Integer> r = intervals.get(0); for (Pair<Integer, Integer> interval : intervals) { Range<Integer> range = Range.closed(interval.getKey(), interval.getValue()); int i = 0; added: { // add the interval to the first row that doesn't intersect with while (i < rows.size()) { TreeRangeSet<Integer> set = rows.get(i); RangeSet<Integer> intersection = set.subRangeSet( Range.closed(interval.getKey() - minSpace, interval.getValue() + minSpace)); if (intersection.isEmpty()) { set.add(range); break added; } i++; } TreeRangeSet<Integer> row = TreeRangeSet.create(); row.add(range); rows.add(row); } } List<Node> content = new ArrayList<>(); for (RangeSet<Integer> row : rows) { RangeSetIntervalView rowView = new RangeSetIntervalView(min, max); rowView.setData(row); content.add(rowView); } getChildren().setAll(content); }
From source file:org.mskcc.shenkers.view.GenericStackedIntervalView.java
public void setData(List<Pair<Integer, Integer>> intervals, List<T> content) { rows.clear();//from w w w .j a va2 s . co m rowNodes.clear(); rows.add(TreeRangeSet.create()); rowNodes.add(new ArrayList<>()); List<IntervalNode<T>> nodes = Stream.iterate(0, i -> i + 1).limit(intervals.size()) .map(i -> new IntervalNode<T>(intervals.get(i), content.get(i))).collect(Collectors.toList()); Collections.sort(nodes, new Comparator<IntervalNode<T>>() { @Override public int compare(IntervalNode<T> o1, IntervalNode<T> o2) { return o1.interval.getKey() - o2.interval.getKey(); } }); for (IntervalNode inode : nodes) { Pair<Integer, Integer> interval = inode.interval; Range<Integer> range = Range.closed(interval.getKey(), interval.getValue()); logger.info("stacking {}", interval); int i = 0; added: { // add the interval to the first row that doesn't intersect with while (i < rows.size()) { TreeRangeSet<Integer> set = rows.get(i); List<IntervalNode<T>> rowContent = rowNodes.get(i); RangeSet<Integer> intersection = set.subRangeSet( Range.closed(interval.getKey() - minSpace, interval.getValue() + minSpace)); if (intersection.isEmpty()) { set.add(range); rowContent.add(inode); logger.info("no intersections in row {}", i); break added; } logger.info("intersects in row {} {}", i, set); i++; } TreeRangeSet<Integer> row = TreeRangeSet.create(); row.add(range); rows.add(row); List<IntervalNode<T>> rowContent = new ArrayList<>(); rowContent.add(inode); rowNodes.add(rowContent); } } // { // Rectangle background = new Rectangle(); // background.setFill(Color.WHITE); // background.widthProperty().bind(widthProperty()); // background.heightProperty().bind(heightProperty()); // getChildren().add(background); // } List<T> children = new ArrayList<>(); for (List<IntervalNode<T>> row : rowNodes) { GenericIntervalView<T> rowView = new GenericIntervalView<>(min, max); List<Pair<Integer, Integer>> rowIntervals = new ArrayList<>(row.size()); List<T> rowContent = new ArrayList<>(row.size()); row.stream().forEach(i -> { rowIntervals.add(i.interval); rowContent.add(i.content); }); rowView.setData(rowIntervals, rowContent); rowView.flipDomainProperty().bind(flipDomain); children.add((T) rowView); } getChildren().addAll(children); }
From source file:org.robotframework.red.nattable.painter.RedTableTextPainter.java
private RangeSet<Integer> getHyperlinks(final TableCellStringData data, final String text, final String originalText) { final List<TableCellStringData> datas = data == null ? new ArrayList<>() : Lists.<TableCellStringData>newArrayList(data); final List<Range<Integer>> hyperlinkRanges = datas.stream().map(TableCellStringData::getHyperlinkRegion) .filter(notNull()).collect(toList()); final RangeSet<Integer> hyperlinksRanges = mapOriginalRangesToCurrentLabel(hyperlinkRanges, text, originalText);/*from w w w . ja v a 2 s .c o m*/ if (hyperlinksRanges.isEmpty()) { hyperlinksRanges.add(Range.closed(-1, -1)); } return hyperlinksRanges; }
From source file:eu.trentorise.opendata.semtext.SemText.java
/** * Returns a copy of the this SemText without terms intersecting provided * ranges.//ww w. j av a2 s. c o m * */ // note: Current version is inefficient, tried RangeMap.remove, but it only removes matching subsegments! public SemText deleteTerms(Iterable<Range<Integer>> deletionRanges) { checkNotNull(deletionRanges); ImmutableList.Builder<Sentence> sentencesB = ImmutableList.builder(); RangeSet<Integer> rangeSet = TreeRangeSet.create(); for (Range r : deletionRanges) { rangeSet.add(r); } for (Sentence sentence : sentences) { ImmutableList.Builder<Term> termsB = ImmutableList.builder(); for (Term term : sentence.getTerms()) { RangeSet<Integer> intersection = rangeSet.subRangeSet(SemTexts.spanToRange(term)); if (intersection.isEmpty()) { termsB.add(term); } } sentencesB.add(sentence.withTerms(termsB.build())); } return this.withSentences(sentencesB.build()); }
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 ava 2s.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:hudson.model.Fingerprint.java
/** * Trim off references to non-existent builds and jobs, thereby making the fingerprint smaller. * * @return true/*w ww .j a va 2s . co m*/ * if this record was modified. * * @throws IOException Save failure */ public synchronized boolean trim() throws IOException { boolean modified = false; for (Entry<String, RangeSet> e : new Hashtable<String, RangeSet>(usages).entrySet()) {// copy because we mutate Job j = Jenkins.getInstance().getItemByFullName(e.getKey(), Job.class); if (j == null) {// no such job any more. recycle the record modified = true; usages.remove(e.getKey()); continue; } Run firstBuild = j.getFirstBuild(); if (firstBuild == null) {// no builds. recycle the whole record modified = true; usages.remove(e.getKey()); continue; } RangeSet cur = e.getValue(); // builds that are around without the keepLog flag on are normally clustered together (in terms of build #) // so our basic strategy is to discard everything up to the first ephemeral build, except those builds // that are marked as kept RangeSet kept = new RangeSet(); Run r = firstBuild; while (r != null && r.isKeepLog()) { kept.add(r.getNumber()); r = r.getNextBuild(); } if (r == null) { // all the build records are permanently kept ones, so we'll just have to keep 'kept' out of whatever currently in 'cur' modified |= cur.retainAll(kept); } else { // otherwise we are ready to discard [0,r.number) except those marked as 'kept' RangeSet discarding = new RangeSet(new Range(-1, r.getNumber())); discarding.removeAll(kept); modified |= cur.removeAll(discarding); } if (cur.isEmpty()) { usages.remove(e.getKey()); modified = true; } } if (modified) { if (logger.isLoggable(Level.FINE)) { logger.log(Level.FINE, "Saving trimmed {0}", getFingerprintFile(md5sum)); } save(); } return modified; }
From source file:com.rockhoppertech.music.fx.cmn.model.MeasureSymbolManager.java
/** * Clear out the existing shapes, then calculate and add new ones. Draws a * simple representation. Does not pay any attention to the note's start * time. That what the MeasureCanvas will do when finished. *//*from w ww. ja v a2s .c o m*/ public void refresh() { logger.debug("refreshing"); if (model == null) { return; } shapes.clear(); symbols.clear(); // // double x = model.getStartX() + 1d // * model.getFontSize(); double x = model.getBeginningBarlineX(); // this will be at model startx // sets first note x x = createStaves(); // x = this.model.getStartX(); if (this.drawTimeSignature) { if (!this.drawKeySignature) x += model.getFontSize() / 2d; x = addTimeSignature(x, 4, 4); } // model.setFirstNoteX(x); this.createBeatRectangles(); if (noteList == null) { return; } if (noteList.isEmpty()) { return; } logger.debug("notelist {}", this.noteList); // TODO this doesn't cover initial rests i.e. when start beat > 1 // TODO rests > 5 beats long don't work well MIDINote previousNote = noteList.get(0); MIDINote firstNote = noteList.get(0); double gap = firstNote.getStartBeat() - 1d; double eb = 1d; double beats = (double) measure.getTimeSignature().getNumerator(); RangeSet<Double> durSet = TreeRangeSet.create(); durSet.add(Range.closed(1d, beats)); logger.debug("initial durSet {} beats {}", durSet, beats); for (MIDINote note : noteList) { Range<Double> noteRange = Range.closed(note.getStartBeat(), note.getEndBeat()); durSet.remove(noteRange); logger.debug("durSet {} after removing {}", durSet, noteRange); logger.debug("beat {} beat in measure {}", note.getStartBeat(), measure.getBeatInMeasure(note)); // figure out if there is a rest double sb = note.getStartBeat(); if (sb > 1d) { eb = previousNote.getEndBeat(); } gap = sb - eb; double restbeat = (sb - gap) - this.measure.getStartBeat() + 1d; x = getXofBeatN(restbeat); logger.debug("sb {} eb {} gap {} x {} restbeat {}", sb, eb, gap, x, restbeat); if (gap > 0) { int pitch = note.getPitch().getMidiNumber(); x = addRests(x, gap, pitch); x += model.getFontSize() / 2d; logger.debug("x {} after adding rest", x); } else { x += model.getFontSize() / 2d; } // now worry about the note x = getXofBeatN(measure.getBeatInMeasure(note)); // x = createSymbol(note, x); x = createStaffSymbol(note, x); logger.debug("x {} after adding symbol", x); if (gap >= 0) { logger.debug("adding padding"); // some padding between the symbols x += model.getFontSize() / 2d; logger.debug("x {} after adding gap 0 spacingl", x); } gap = 0; previousNote = note; } logger.debug("final durSet {}", durSet); if (!durSet.isEmpty()) { // then there are rests for (Range<Double> restRange : durSet.asRanges()) { logger.debug("restRange {}", restRange); } } // push all the x locations to be the previous x + width // make sure all the rects are large enough, adjust widths and x // locations. enlargeBeatRectangles(); // resize the staves to the new rectangles createStaves(); }