@Nullable public static Range create(final int singletonValue) { return singletonValue < 0 ? null : new Range(singletonValue, singletonValue + 1); }
public boolean connectedWith(final Iterable<Range> ranges) { for (final Range range : ranges) { if (connectedWith(range)) { return true; } } return false; }
public boolean containedIn(final Iterable<Range> ranges) { for (final Range range : ranges) { if (range.contains(this)) { return true; } } return false; }
@Nullable public static Range valueOf(final String string) { final String trimmedSpan = string.trim(); final int delimiter = trimmedSpan.indexOf(','); final int begin = Integer.parseInt(trimmedSpan.substring(0, delimiter)); final int end = Integer.parseInt(trimmedSpan.substring(delimiter + 1)); return create(begin, end); }
public List<Range> split(final Iterable<Range> ranges) { final List<Range> sortedRanges = separate(ranges); final List<Range> result = Lists.newArrayList(); int index = this.begin; for (final Range range : sortedRanges) { if (range.begin >= this.end) { break; } if (range.begin > index) { result.add(new Range(index, range.begin)); index = range.begin; } if (range.end > index) { final int end = Math.min(range.end, this.end); result.add(index == range.begin && end == range.end ? range : new Range(index, end)); index = end; } } if (index < this.end) { result.add(new Range(index, this.end)); } return result; }
public boolean overlaps(final Iterable<Range> ranges) { for (final Range range : ranges) { if (overlaps(range)) { return true; } } return false; }
public static List<Range> termRangesFor(final KAFDocument document, final Iterable<Term> terms) { final List<Range> ranges = Lists.newArrayList(); int startIndex = -1; int lastIndex = -2; for (final Term term : Ordering.from(Term.OFFSET_COMPARATOR).sortedCopy(terms)) { final int termIndex = document.getTerms().indexOf(term); if (termIndex - lastIndex > 1) { if (startIndex >= 0) { ranges.add(Range.create(startIndex, lastIndex + 1)); } startIndex = termIndex; } lastIndex = termIndex; } if (startIndex != -1 && lastIndex >= startIndex) { ranges.add(Range.create(startIndex, lastIndex + 1)); } return ranges; }
public static Range rangeFor(final Iterable<Term> terms) { int begin = Integer.MAX_VALUE; int end = Integer.MIN_VALUE; for (final Term term : terms) { begin = Math.min(begin, getBegin(term)); end = Math.max(end, getEnd(term)); } return Range.create(begin, end); }
@Nullable public static Range create(final int begin, final int end) { if (begin < 0 || begin >= end) { return null; } return new Range(begin, end); }
public static List<Range> rangesFor(final KAFDocument document, final Iterable<Term> terms) { final List<Range> ranges = Lists.newArrayList(); int startOffset = -1; int endOffset = -1; int termIndex = -2; for (final Term term : Ordering.from(Term.OFFSET_COMPARATOR).sortedCopy(terms)) { final int lastTermIndex = termIndex; termIndex = document.getTerms().indexOf(term); if (termIndex - lastTermIndex > 1) { if (startOffset != -1) { ranges.add(Range.create(startOffset, endOffset)); } startOffset = term.getOffset(); } endOffset = NAFUtils.getEnd(term); } if (startOffset != -1 && endOffset > startOffset) { ranges.add(Range.create(startOffset, endOffset)); } return ranges; }
@Nullable public static Range enclose(final Iterable<Range> ranges) { int begin = Integer.MAX_VALUE; int end = Integer.MIN_VALUE; for (final Range range : ranges) { begin = Math.min(range.begin, begin); end = Math.max(range.end, end); } return begin >= end ? null : new Range(begin, end); }
public static Range rangeFor(final Term term) { return Range.create(NAFUtils.getBegin(term), NAFUtils.getEnd(term)); }
@Nullable public static Range intersection(final Iterable<Range> ranges) { int begin = Integer.MIN_VALUE; int end = Integer.MAX_VALUE; for (final Range range : ranges) { begin = Math.max(begin, range.begin); end = Math.min(end, range.end); if (begin >= end) { return null; } } return begin > Integer.MIN_VALUE ? new Range(begin, end) : null; }
@Nullable public static Range enclose(final int... values) { int begin = Integer.MAX_VALUE; int end = Integer.MIN_VALUE; for (final int value : values) { if (value < 0) { return null; } begin = Math.min(begin, value); end = Math.max(end, value + 1); } return begin >= end ? null : new Range(begin, end); }
public static List<Range> merge(final Iterable<Range> ranges) { final List<Range> sortedRanges = Ordering.natural().sortedCopy(ranges); int i = 0; while (i < sortedRanges.size() - 1) { final Range range1 = sortedRanges.get(i); final Range range2 = sortedRanges.get(i + 1); if (range1.end >= range2.begin) { final Range merged = new Range(Math.min(range1.begin, range2.begin), Math.max( range1.end, range2.end)); sortedRanges.set(i, merged); sortedRanges.remove(i + 1); } else { ++i; } } return sortedRanges; }
public static List<Range> separate(final Iterable<Range> ranges) { final List<Range> sortedRanges = Lists.newArrayList(ranges); boolean overlaps = true; while (overlaps) { overlaps = false; Collections.sort(sortedRanges); for (int i = 0; i < sortedRanges.size() - 1; ++i) { final Range range1 = sortedRanges.get(i); final Range range2 = sortedRanges.get(i + 1); if (range1.end > range2.begin) { sortedRanges.remove(i); if (range1.begin < range2.begin) { sortedRanges.add(new Range(range1.begin, range2.begin)); } if (range1.end < range2.end) { sortedRanges.remove(i); // former i + 1 sortedRanges.add(new Range(range2.begin, range1.end)); sortedRanges.add(new Range(range1.end, range2.end)); } else if (range1.end > range2.end) { sortedRanges.add(new Range(range2.end, range1.end)); } overlaps = true; break; } } } return sortedRanges; }