public static SortedSet<Interval> computeCompactIntervals(SortedSet<Interval> intervals) { final SortedSet<Interval> compactIntervals = new TreeSet<>(Comparators.intervalsByStartThenEnd()); List<Interval> toBeAccumulated = new ArrayList<>(); for (Interval interval : intervals) { if (toBeAccumulated.size() == 0) { toBeAccumulated.add(interval); } else { if (toBeAccumulated.get(toBeAccumulated.size() - 1).abuts(interval)) { toBeAccumulated.add(interval); } else { compactIntervals.add(JodaUtils.umbrellaInterval(toBeAccumulated)); toBeAccumulated.clear(); toBeAccumulated.add(interval); } } } if (toBeAccumulated.size() > 0) { compactIntervals.add(JodaUtils.umbrellaInterval(toBeAccumulated)); } return compactIntervals; } }
Interval next = intervalsIter.next(); if (currInterval.abuts(next)) { currInterval = new Interval(currInterval.getStart(), next.getEnd()); } else if (currInterval.overlaps(next)) {
for (Map.Entry<Interval, Object> e : servedIntervals.entrySet()) { Interval ival = e.getKey(); if (curr != null && curr.abuts(ival) && cols.equals(e.getValue())) { curr = curr.withEnd(ival.getEnd()); } else {
} else { final Interval currentInterval = chunks.get(0).getObject().getInterval(); isSameOrAbuttingInterval = currentInterval.isEqual(lastInterval) || currentInterval.abuts(lastInterval);
"Intervals should be same or abutting", segments.stream().allMatch( segment -> segment.getInterval().isEqual(firstInterval) || segment.getInterval().abuts(firstInterval)
public static SortedSet<Interval> computeCompactIntervals(SortedSet<Interval> intervals) { final SortedSet<Interval> compactIntervals = new TreeSet<>(Comparators.intervalsByStartThenEnd()); List<Interval> toBeAccumulated = new ArrayList<>(); for (Interval interval : intervals) { if (toBeAccumulated.size() == 0) { toBeAccumulated.add(interval); } else { if (toBeAccumulated.get(toBeAccumulated.size() - 1).abuts(interval)) { toBeAccumulated.add(interval); } else { compactIntervals.add(JodaUtils.umbrellaInterval(toBeAccumulated)); toBeAccumulated = Lists.newArrayList(interval); } } } if (toBeAccumulated.size() > 0) { compactIntervals.add(JodaUtils.umbrellaInterval(toBeAccumulated)); } return compactIntervals; } }
public static SortedSet<Interval> computeCompactIntervals(SortedSet<Interval> intervals) { final SortedSet<Interval> compactIntervals = new TreeSet<>(Comparators.intervalsByStartThenEnd()); List<Interval> toBeAccumulated = new ArrayList<>(); for (Interval interval : intervals) { if (toBeAccumulated.size() == 0) { toBeAccumulated.add(interval); } else { if (toBeAccumulated.get(toBeAccumulated.size() - 1).abuts(interval)) { toBeAccumulated.add(interval); } else { compactIntervals.add(JodaUtils.umbrellaInterval(toBeAccumulated)); toBeAccumulated.clear(); toBeAccumulated.add(interval); } } } if (toBeAccumulated.size() > 0) { compactIntervals.add(JodaUtils.umbrellaInterval(toBeAccumulated)); } return compactIntervals; } }
public static ArrayList<Interval> condenseIntervals(Iterable<Interval> intervals) { ArrayList<Interval> retVal = Lists.newArrayList(); TreeSet<Interval> sortedIntervals = Sets.newTreeSet(Comparators.intervalsByStartThenEnd()); for (Interval interval : intervals) { sortedIntervals.add(interval); } if (sortedIntervals.isEmpty()) { return Lists.newArrayList(); } Iterator<Interval> intervalsIter = sortedIntervals.iterator(); Interval currInterval = intervalsIter.next(); while (intervalsIter.hasNext()) { Interval next = intervalsIter.next(); if (currInterval.overlaps(next) || currInterval.abuts(next)) { currInterval = new Interval(currInterval.getStart(), next.getEnd()); } else { retVal.add(currInterval); currInterval = next; } } retVal.add(currInterval); return retVal; }
public static ArrayList<Interval> condenseIntervals(Iterable<Interval> intervals) { ArrayList<Interval> retVal = Lists.newArrayList(); TreeSet<Interval> sortedIntervals = Sets.newTreeSet(Comparators.intervalsByStartThenEnd()); for (Interval interval : intervals) { sortedIntervals.add(interval); } if (sortedIntervals.isEmpty()) { return Lists.newArrayList(); } Iterator<Interval> intervalsIter = sortedIntervals.iterator(); Interval currInterval = intervalsIter.next(); while (intervalsIter.hasNext()) { Interval next = intervalsIter.next(); if (currInterval.overlaps(next) || currInterval.abuts(next)) { currInterval = new Interval(currInterval.getStart(), next.getEnd()); } else { retVal.add(currInterval); currInterval = next; } } retVal.add(currInterval); return retVal; }
public static ArrayList<Interval> condenseIntervals(Iterable<Interval> intervals) { ArrayList<Interval> retVal = Lists.newArrayList(); TreeSet<Interval> sortedIntervals = Sets.newTreeSet(Comparators.intervalsByStartThenEnd()); for (Interval interval : intervals) { sortedIntervals.add(interval); } if (sortedIntervals.isEmpty()) { return Lists.newArrayList(); } Iterator<Interval> intervalsIter = sortedIntervals.iterator(); Interval currInterval = intervalsIter.next(); while (intervalsIter.hasNext()) { Interval next = intervalsIter.next(); if (currInterval.overlaps(next) || currInterval.abuts(next)) { currInterval = new Interval(currInterval.getStart(), next.getEnd()); } else { retVal.add(currInterval); currInterval = next; } } retVal.add(currInterval); return retVal; }
public static SortedSet<Interval> flatten(final SortedSet<Interval> intervalsSet) { if (intervalsSet.size() < 2) { return intervalsSet; } SortedSet<Interval> flattenIntervals = newSortedSet(); Interval prev = intervalsSet.first(); flattenIntervals.add(prev); for (Interval interval : intervalsSet) { if (interval.contains(prev.getEnd()) || interval.abuts(prev)) { Interval sumInterval = new Interval(prev.getStart(), interval.getEnd()); flattenIntervals.remove(prev); flattenIntervals.add(sumInterval); prev = sumInterval; } else if (!prev.contains(interval)) { flattenIntervals.add(interval); prev = interval; } } return flattenIntervals; }
Interval next = intervalsIter.next(); if (currInterval.abuts(next)) { currInterval = new Interval(currInterval.getStart(), next.getEnd()); } else if (currInterval.overlaps(next)) {
Interval next = intervalsIter.next(); if (currInterval.abuts(next)) { currInterval = new Interval(currInterval.getStart(), next.getEnd()); } else if (currInterval.overlaps(next)) {
/** * Merge all contiguous and overlapping intervals in a set together and return the set with the merged intervals. * * @param unmergedIntervals A set of intervals that may abut or overlap * * @return The set of merged intervals */ public static Set<Interval> mergeIntervalSet(Set<Interval> unmergedIntervals) { // Create a self sorting set of intervals TreeSet<Interval> sortedIntervals = new TreeSet<>(IntervalStartComparator.INSTANCE); for (Interval mergingInterval : unmergedIntervals) { Iterator<Interval> it = sortedIntervals.iterator(); while (it.hasNext()) { Interval sortedInterval = it.next(); if (mergingInterval.overlaps(sortedInterval) || mergingInterval.abuts(sortedInterval)) { // Remove the interval being merged with it.remove(); // find start and end of new interval DateTime start = (mergingInterval.getStart().isBefore(sortedInterval.getStart())) ? mergingInterval.getStart() : sortedInterval.getStart(); DateTime end = (mergingInterval.getEnd().isAfter(sortedInterval.getEnd())) ? mergingInterval.getEnd() : sortedInterval.getEnd(); mergingInterval = new Interval(start, end); } } sortedIntervals.add(mergingInterval); } return sortedIntervals; }
for (Map.Entry<Interval, Object> e : servedIntervals.entrySet()) { Interval ival = e.getKey(); if (curr != null && curr.abuts(ival) && cols.equals(e.getValue())) { curr = curr.withEnd(ival.getEnd()); } else {
for (Map.Entry<Interval, Object> e : servedIntervals.entrySet()) { Interval ival = e.getKey(); if (curr != null && curr.abuts(ival) && cols.equals(e.getValue())) { curr = curr.withEnd(ival.getEnd()); } else {