/** * <p>addAll</p> * * @param intervals a {@link org.opennms.core.utils.AbstractTimeIntervalSequence} object. */ public void addAll(AbstractTimeIntervalSequence<T> intervals) { for (Iterator<T> it = intervals.iterator(); it.hasNext();) { T interval = it.next(); addInterval(interval); } }
private void addOverlappingInterval(T newInterval) { // overlapping intervals Collection<T> newIntervals = combineIntervals(m_interval, newInterval); // remove the current interval since we are replacing it with the new ones removeCurrent(); // now add the new intervals addAll(newIntervals); }
private void addPreceedingInterval(T interval) { // new interval is later than current interval so add it to the tail addToTail(interval); }
private void addToTail(T interval) { if (m_tail == null) { m_tail = createTail(interval); } else { m_tail.addInterval(interval); } }
/** * <p>bound</p> * * @param start a {@link java.util.Date} object. * @param end a {@link java.util.Date} object. */ public void bound(Date start, Date end) { removeInterval(createInterval(new Date(0), start)); removeInterval(createInterval(end, new Date(Long.MAX_VALUE))); }
removeFromTail(removedInterval); } else if (m_interval.follows(removedInterval)) { removeFromTail(removedInterval); removeCurrent(); Collection<T> newIntervals = separateIntervals(origInterval, removedInterval); addAll(newIntervals);
/** * <p>removeAll</p> * * @param intervals a {@link org.opennms.core.utils.AbstractTimeIntervalSequence} object. */ public void removeAll(AbstractTimeIntervalSequence<T> intervals) { for (Iterator<T> it = intervals.iterator(); it.hasNext();) { T interval = it.next(); removeInterval(interval); } }
/** * <p>addInterval</p> * * @param interval a {@link org.opennms.core.utils.TimeInterval} object. */ public void addInterval(T interval) { if (m_interval == null) { m_interval = interval; } else if (m_interval.preceeds(interval)) { addPreceedingInterval(interval); } else if (m_interval.follows(interval)) { addSucceedingInterval(interval); } else if (m_interval.overlaps(interval)) { addOverlappingInterval(interval); } }
Date first = min(currentInterval.getStart(), newInterval.getStart()); Date second = max(currentInterval.getStart(), newInterval.getStart()); Date third = min(currentInterval.getEnd(), newInterval.getEnd()); Date fourth = max(currentInterval.getEnd(), newInterval.getEnd()); newIntervals.add(createInterval(first, third)); } else { newIntervals.add(createInterval(first, second)); newIntervals.add(createInterval(second, third)); newIntervals.add(createInterval(third, fourth));
/** * <p>toString</p> * * @return a {@link java.lang.String} object. */ @Override public String toString() { final StringBuilder buf = new StringBuilder("["); boolean first = true; for (Iterator<? extends TimeInterval> it = this.iterator(); it.hasNext();) { TimeInterval interval = (TimeInterval) it.next(); if (first) { first = false; } else { buf.append(","); } buf.append(interval); } buf.append(']'); return buf.toString(); }
/** * <p>addAll</p> * * @param intervals a {@link java.util.Collection} object. */ public void addAll(Collection<T> intervals) { for (Iterator<T> it = intervals.iterator(); it.hasNext();) { T interval = it.next(); addInterval(interval); } }
/** * <p>bound</p> * * @param interval a {@link org.opennms.core.utils.TimeInterval} object. */ public void bound(T interval) { bound(interval.getStart(), interval.getEnd()); }
/** * <p>separateIntervals</p> * * @param origInterval a {@link org.opennms.core.utils.TimeInterval} object. * @param removedInterval a {@link org.opennms.core.utils.TimeInterval} object. * @return a {@link java.util.Collection} object. */ protected Collection<T> separateIntervals(T origInterval, T removedInterval) { List<T> newIntervals = new ArrayList<T>(2); if (removedInterval.getEnd().before(origInterval.getEnd())) { newIntervals.add(createInterval(removedInterval.getEnd(), origInterval.getEnd())); } // add back any part of the original interval the preceeded the remove interval if (origInterval.getStart().before(removedInterval.getStart())) { newIntervals.add(createInterval(origInterval.getStart(), removedInterval.getStart())); } return newIntervals; }
protected <T extends TimeInterval> void assertTimeIntervalSequence(T[] intervals, AbstractTimeIntervalSequence<T> seq) { int count = 0; for (Iterator<T> iter = seq.iterator(); iter.hasNext();) { T interval = iter.next(); assertInterval(intervals[count], interval); count++; } assertEquals(intervals.length, count); }