private void updateInterval(Optional<String> start, Optional<String> end) { if (start.isPresent() && end.isPresent()) { String startString = start.get(); String endString = end.get(); try { if (interval != null) { Duration duration = interval.toDuration(); duration = duration.plus(1000); if ("next".equals(startString) && startString.equals(endString)) { interval = new Interval( interval.getStart().plus(duration) // , interval.getEnd().plus(duration)); } else if ("prev".equals(startString) && startString.equals(endString)) { interval = new Interval( interval.getStart().minus(duration) // , interval.getEnd().minus(duration)); } else { parseInterval(startString, endString); } } else { parseInterval(startString, endString); } idsOnClient.clear(); idsOnClient.add("force reload"); } catch (Exception e) { log.error("", e); } } }
/** * Does this time interval contain the specified time interval. * * <p>Non-zero duration intervals are inclusive of the start instant and exclusive of the end. The * other interval is contained if this interval wholly contains, starts, finishes or equals it. A * zero duration interval cannot contain anything. * * <p>When two intervals are compared the result is one of three states: (a) they abut, (b) there * is a gap between them, (c) they overlap. The <code>contains</code> method is not related to * these states. In particular, a zero duration interval is contained at the start of a larger * interval, but does not overlap (it abuts instead). * * <p>For example: * * <pre> * [09:00 to 10:00) contains [09:00 to 10:00) = true * [09:00 to 10:00) contains [09:00 to 09:30) = true * [09:00 to 10:00) contains [09:30 to 10:00) = true * [09:00 to 10:00) contains [09:15 to 09:45) = true * [09:00 to 10:00) contains [09:00 to 09:00) = true * * [09:00 to 10:00) contains [08:59 to 10:00) = false (otherStart before thisStart) * [09:00 to 10:00) contains [09:00 to 10:01) = false (otherEnd after thisEnd) * [09:00 to 10:00) contains [10:00 to 10:00) = false (otherStart equals thisEnd) * * [14:00 to 14:00) contains [14:00 to 14:00) = false (zero duration contains nothing) * </pre> * * Passing in a <code>null</code> parameter will have the same effect as calling {@link * #containsNow()}. * * @param interval the time interval to compare to, null means a zero duration interval now * @return true if this time interval contains the time interval */ public boolean contains(ReadableInterval interval) { if (interval == null) { return containsNow(); } long otherStart = interval.getStartMillis(); long otherEnd = interval.getEndMillis(); long thisStart = getStartMillis(); long thisEnd = getEndMillis(); return (thisStart <= otherStart && otherStart < thisEnd && otherEnd <= thisEnd); }
/** * Compares this object with the specified object for equality based on start and end millis plus * the chronology. All ReadableInterval instances are accepted. * * <p>To compare the duration of two time intervals, use {@link #toDuration()} to get the * durations and compare those. * * @param readableInterval a readable interval to check against * @return true if the intervals are equal comparing the start millis, end millis and chronology */ public boolean equals(Object readableInterval) { if (this == readableInterval) { return true; } if (readableInterval instanceof ReadableInterval == false) { return false; } ReadableInterval other = (ReadableInterval) readableInterval; return getStartMillis() == other.getStartMillis() && getEndMillis() == other.getEndMillis() && FieldUtils.equals(getChronology(), other.getChronology()); }
/** * Does this time interval overlap the specified time interval. * * <p>Intervals are inclusive of the start instant and exclusive of the end. An interval overlaps * another if it shares some common part of the datetime continuum. * * <p>When two intervals are compared the result is one of three states: (a) they abut, (b) there * is a gap between them, (c) they overlap. The abuts state takes precedence over the other two, * thus a zero duration interval at the start of a larger interval abuts and does not overlap. * * <p>For example: * * <pre> * [09:00 to 10:00) overlaps [08:00 to 08:30) = false (completely before) * [09:00 to 10:00) overlaps [08:00 to 09:00) = false (abuts before) * [09:00 to 10:00) overlaps [08:00 to 09:30) = true * [09:00 to 10:00) overlaps [08:00 to 10:00) = true * [09:00 to 10:00) overlaps [08:00 to 11:00) = true * * [09:00 to 10:00) overlaps [09:00 to 09:00) = false (abuts before) * [09:00 to 10:00) overlaps [09:00 to 09:30) = true * [09:00 to 10:00) overlaps [09:00 to 10:00) = true * [09:00 to 10:00) overlaps [09:00 to 11:00) = true * * [09:00 to 10:00) overlaps [09:30 to 09:30) = true * [09:00 to 10:00) overlaps [09:30 to 10:00) = true * [09:00 to 10:00) overlaps [09:30 to 11:00) = true * * [09:00 to 10:00) overlaps [10:00 to 10:00) = false (abuts after) * [09:00 to 10:00) overlaps [10:00 to 11:00) = false (abuts after) * * [09:00 to 10:00) overlaps [10:30 to 11:00) = false (completely after) * * [14:00 to 14:00) overlaps [14:00 to 14:00) = false (abuts before and after) * [14:00 to 14:00) overlaps [13:00 to 15:00) = true * </pre> * * @param interval the time interval to compare to, null means a zero length interval now * @return true if the time intervals overlap */ public boolean overlaps(ReadableInterval interval) { long thisStart = getStartMillis(); long thisEnd = getEndMillis(); if (interval == null) { long now = DateTimeUtils.currentTimeMillis(); return (thisStart < now && now < thisEnd); } else { long otherStart = interval.getStartMillis(); long otherEnd = interval.getEndMillis(); return (thisStart < otherEnd && otherStart < thisEnd); } }
public static boolean isContainedIn(Absence a, ReadableInterval i) { if (a.getType() == null || i == null) return false; Chronology chron = i.getChronology(); switch (a.getType()) { case Absence: return i.contains(a.getInterval(chron)); case EarlyCheckOut: DateTime checkout = a.getCheckout(chron); return i.contains(checkout); case Tardy: DateTime checkin = a.getCheckin(chron); return i.contains(checkin); default: throw new UnsupportedOperationException(); } }
/** * Is this time interval entirely after the specified interval. * * <p>Intervals are inclusive of the start instant and exclusive of the end. Only the end time of * the specified interval is used in the comparison. * * @param interval the interval to compare to, null means now * @return true if this time interval is after the interval specified */ public boolean isAfter(ReadableInterval interval) { long endMillis; if (interval == null) { endMillis = DateTimeUtils.currentTimeMillis(); } else { endMillis = interval.getEndMillis(); } return (getStartMillis() >= endMillis); }
/** * Is this time interval entirely before the specified instant. * * <p>Intervals are inclusive of the start instant and exclusive of the end. * * @param interval the interval to compare to, null means now * @return true if this time interval is before the interval specified */ public boolean isBefore(ReadableInterval interval) { if (interval == null) { return isBeforeNow(); } return isBefore(interval.getStartMillis()); }
/** * Is this interval equal to the specified interval ignoring the chronology. * * <p>This compares the underlying instants, ignoring the chronology. * * @param other a readable interval to check against * @return true if the intervals are equal comparing the start and end millis * @since 2.3 */ public boolean isEqual(ReadableInterval other) { return getStartMillis() == other.getStartMillis() && getEndMillis() == other.getEndMillis(); }