Java tutorial
/************************************************************************************** * Copyright (C) 2008 EsperTech, Inc. All rights reserved. * * http://esper.codehaus.org * * http://www.espertech.com * * ---------------------------------------------------------------------------------- * * The software in this package is published under the terms of the GPL license * * a copy of which has been included with this distribution in the license.txt file. * **************************************************************************************/ package com.espertech.esper.schedule; import com.espertech.esper.type.CronOperatorEnum; import com.espertech.esper.type.CronParameter; import com.espertech.esper.type.ScheduleUnit; import com.espertech.esper.util.ExecutionPathDebugLog; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import java.util.Calendar; import java.util.Date; import java.util.SortedSet; import java.util.TimeZone; /** * For a crontab-like schedule, this class computes the next occurance given a start time and a specification of * what the schedule looks like. * The resolution at which this works is at the second level. The next occurance * is always at least 1 second ahead. * The class implements an algorithm that starts at the highest precision (seconds) and * continues to the lowest precicion (month). For each precision level the * algorithm looks at the list of valid values and finds a value for each that is equal to or greater then * the valid values supplied. If no equal or * greater value was supplied, it will reset all higher precision elements to its minimum value. */ public final class ScheduleComputeHelper { private static final Log log = LogFactory.getLog(ScheduleComputeHelper.class); private static int[] DAY_OF_WEEK_ARRAY = new int[] { Calendar.SUNDAY, Calendar.MONDAY, Calendar.TUESDAY, Calendar.WEDNESDAY, Calendar.THURSDAY, Calendar.FRIDAY, Calendar.SATURDAY }; /** * Minimum time to next occurance. */ private static final int MIN_OFFSET_MSEC = 1000; /** * Computes the next lowest date in milliseconds based on a specification and the * from-time passed in. * @param spec defines the schedule * @param afterTimeInMillis defines the start time * @return a long date millisecond value for the next schedule occurance matching the spec */ public static long computeNextOccurance(ScheduleSpec spec, long afterTimeInMillis) { if ((ExecutionPathDebugLog.isDebugEnabled) && (log.isDebugEnabled())) { log.debug(".computeNextOccurance Computing next occurance, afterTimeInMillis=" + (new Date(afterTimeInMillis)) + " as long=" + afterTimeInMillis + " spec=" + spec); } // Add the minimum resolution to the start time to ensure we don't get the same exact time if (spec.getUnitValues().containsKey(ScheduleUnit.SECONDS)) { afterTimeInMillis += MIN_OFFSET_MSEC; } else { afterTimeInMillis += 60 * MIN_OFFSET_MSEC; } return compute(spec, afterTimeInMillis); } /** * Computes the next lowest date in milliseconds based on a specification and the * from-time passed in and returns the delta from the current time. * @param spec defines the schedule * @param afterTimeInMillis defines the start time * @return a long millisecond value representing the delta between current time and the next schedule occurance matching the spec */ public static long computeDeltaNextOccurance(ScheduleSpec spec, long afterTimeInMillis) { return computeNextOccurance(spec, afterTimeInMillis) - afterTimeInMillis; } private static long compute(ScheduleSpec spec, long afterTimeInMillis) { while (true) { Calendar after; if (spec.getOptionalTimeZone() != null) { after = Calendar.getInstance(TimeZone.getTimeZone(spec.getOptionalTimeZone())); } else { after = Calendar.getInstance(); } after.setTimeInMillis(afterTimeInMillis); ScheduleCalendar result = new ScheduleCalendar(); result.setMilliseconds(after.get(Calendar.MILLISECOND)); SortedSet<Integer> minutesSet = spec.getUnitValues().get(ScheduleUnit.MINUTES); SortedSet<Integer> hoursSet = spec.getUnitValues().get(ScheduleUnit.HOURS); SortedSet<Integer> monthsSet = spec.getUnitValues().get(ScheduleUnit.MONTHS); SortedSet<Integer> secondsSet = null; boolean isSecondsSpecified = false; if (spec.getUnitValues().containsKey(ScheduleUnit.SECONDS)) { isSecondsSpecified = true; secondsSet = spec.getUnitValues().get(ScheduleUnit.SECONDS); } if (isSecondsSpecified) { result.setSecond(nextValue(secondsSet, after.get(Calendar.SECOND))); if (result.getSecond() == -1) { result.setSecond(nextValue(secondsSet, 0)); after.add(Calendar.MINUTE, 1); } } result.setMinute(nextValue(minutesSet, after.get(Calendar.MINUTE))); if (result.getMinute() != after.get(Calendar.MINUTE)) { result.setSecond(nextValue(secondsSet, 0)); } if (result.getMinute() == -1) { result.setMinute(nextValue(minutesSet, 0)); after.add(Calendar.HOUR_OF_DAY, 1); } result.setHour(nextValue(hoursSet, after.get(Calendar.HOUR_OF_DAY))); if (result.getHour() != after.get(Calendar.HOUR_OF_DAY)) { result.setSecond(nextValue(secondsSet, 0)); result.setMinute(nextValue(minutesSet, 0)); } if (result.getHour() == -1) { result.setHour(nextValue(hoursSet, 0)); after.add(Calendar.DAY_OF_MONTH, 1); } // This call may change second, minute and/or hour parameters // They may be reset to minimum values if the day rolled result.setDayOfMonth(determineDayOfMonth(spec, after, result)); boolean dayMatchRealDate = false; while (!dayMatchRealDate) { if (checkDayValidInMonth(result.getDayOfMonth(), after.get(Calendar.MONTH), after.get(Calendar.YEAR))) { dayMatchRealDate = true; } else { after.add(Calendar.MONTH, 1); } } int currentMonth = after.get(Calendar.MONTH) + 1; result.setMonth(nextValue(monthsSet, currentMonth)); if (result.getMonth() != currentMonth) { result.setSecond(nextValue(secondsSet, 0)); result.setMinute(nextValue(minutesSet, 0)); result.setHour(nextValue(hoursSet, 0)); result.setDayOfMonth(determineDayOfMonth(spec, after, result)); } if (result.getMonth() == -1) { result.setMonth(nextValue(monthsSet, 0)); after.add(Calendar.YEAR, 1); } // Perform a last valid date check, if failing, try to compute a new date based on this altered after date int year = after.get(Calendar.YEAR); if (!(checkDayValidInMonth(result.getDayOfMonth(), result.getMonth() - 1, year))) { afterTimeInMillis = after.getTimeInMillis(); continue; } return getTime(result, after.get(Calendar.YEAR), spec.getOptionalTimeZone()); } } /* * Determine the next valid day of month based on the given specification of valid days in month and * valid days in week. If both days in week and days in month are supplied, the days are OR-ed. */ private static int determineDayOfMonth(ScheduleSpec spec, Calendar after, ScheduleCalendar result) { SortedSet<Integer> daysOfMonthSet = spec.getUnitValues().get(ScheduleUnit.DAYS_OF_MONTH); SortedSet<Integer> daysOfWeekSet = spec.getUnitValues().get(ScheduleUnit.DAYS_OF_WEEK); SortedSet<Integer> secondsSet = spec.getUnitValues().get(ScheduleUnit.SECONDS); SortedSet<Integer> minutesSet = spec.getUnitValues().get(ScheduleUnit.MINUTES); SortedSet<Integer> hoursSet = spec.getUnitValues().get(ScheduleUnit.HOURS); int dayOfMonth; // If days of week is a wildcard, just go by days of month if (spec.getOptionalDayOfMonthOperator() != null || spec.getOptionalDayOfWeekOperator() != null) { boolean isWeek = false; CronParameter op = spec.getOptionalDayOfMonthOperator(); if (spec.getOptionalDayOfMonthOperator() == null) { op = spec.getOptionalDayOfWeekOperator(); isWeek = true; } // may return the current day or a future day in the same month, // and may advance the "after" date to the next month int currentYYMMDD = getTimeYYYYMMDD(after); increaseAfterDayOfMonthSpecialOp(op.getOperator(), op.getDay(), op.getMonth(), isWeek, after); int rolledYYMMDD = getTimeYYYYMMDD(after); // if rolled then reset time portion if (rolledYYMMDD > currentYYMMDD) { result.setSecond(nextValue(secondsSet, 0)); result.setMinute(nextValue(minutesSet, 0)); result.setHour(nextValue(hoursSet, 0)); return after.get(Calendar.DAY_OF_MONTH); } // rolling backwards is not allowed else if (rolledYYMMDD < currentYYMMDD) { throw new IllegalStateException( "Failed to evaluate special date op, rolled date less then current date"); } else { Calendar work = (Calendar) after.clone(); work.set(Calendar.SECOND, result.getSecond()); work.set(Calendar.MINUTE, result.getMinute()); work.set(Calendar.HOUR_OF_DAY, result.getHour()); if (!work.after(after)) { // new date is not after current date, so bump after.add(Calendar.DAY_OF_MONTH, 1); result.setSecond(nextValue(secondsSet, 0)); result.setMinute(nextValue(minutesSet, 0)); result.setHour(nextValue(hoursSet, 0)); increaseAfterDayOfMonthSpecialOp(op.getOperator(), op.getDay(), op.getMonth(), isWeek, after); } return after.get(Calendar.DAY_OF_MONTH); } } else if (daysOfWeekSet == null) { dayOfMonth = nextValue(daysOfMonthSet, after.get(Calendar.DAY_OF_MONTH)); if (dayOfMonth != after.get(Calendar.DAY_OF_MONTH)) { result.setSecond(nextValue(secondsSet, 0)); result.setMinute(nextValue(minutesSet, 0)); result.setHour(nextValue(hoursSet, 0)); } if (dayOfMonth == -1) { dayOfMonth = nextValue(daysOfMonthSet, 0); after.add(Calendar.MONTH, 1); } } // If days of weeks is not a wildcard and days of month is a wildcard, go by days of week only else if (daysOfMonthSet == null) { // Loop to find the next day of month that works for the specified day of week values while (true) { dayOfMonth = after.get(Calendar.DAY_OF_MONTH); int dayOfWeek = after.get(Calendar.DAY_OF_WEEK) - 1; // If the day matches neither the day of month nor the day of week if (!daysOfWeekSet.contains(dayOfWeek)) { result.setSecond(nextValue(secondsSet, 0)); result.setMinute(nextValue(minutesSet, 0)); result.setHour(nextValue(hoursSet, 0)); after.add(Calendar.DAY_OF_MONTH, 1); } else { break; } } } // Both days of weeks and days of month are not a wildcard else { // Loop to find the next day of month that works for either day of month OR day of week while (true) { dayOfMonth = after.get(Calendar.DAY_OF_MONTH); int dayOfWeek = after.get(Calendar.DAY_OF_WEEK) - 1; // If the day matches neither the day of month nor the day of week if ((!daysOfWeekSet.contains(dayOfWeek)) && (!daysOfMonthSet.contains(dayOfMonth))) { result.setSecond(nextValue(secondsSet, 0)); result.setMinute(nextValue(minutesSet, 0)); result.setHour(nextValue(hoursSet, 0)); after.add(Calendar.DAY_OF_MONTH, 1); } else { break; } } } return dayOfMonth; } private static long getTime(ScheduleCalendar result, int year, String optionalTimeZone) { Calendar calendar; if (optionalTimeZone != null) { calendar = Calendar.getInstance(TimeZone.getTimeZone(optionalTimeZone)); } else { calendar = Calendar.getInstance(); } calendar.set(year, result.getMonth() - 1, result.getDayOfMonth(), result.getHour(), result.getMinute(), result.getSecond()); calendar.set(Calendar.MILLISECOND, result.getMilliseconds()); return calendar.getTimeInMillis(); } /* * Check if this is a valid date. */ private static boolean checkDayValidInMonth(int day, int month, int year) { try { Calendar calendar = Calendar.getInstance(); calendar.setLenient(false); calendar.set(Calendar.YEAR, year); calendar.set(Calendar.MONTH, month); calendar.set(Calendar.DAY_OF_MONTH, day); calendar.getTime(); } catch (IllegalArgumentException e) { return false; } return true; } /* * Determine if in the supplied valueSet there is a value after the given start value. * Return -1 to indicate that there is no value after the given startValue. * If the valueSet passed is null it is treated as a wildcard and the same startValue is returned */ private static int nextValue(SortedSet<Integer> valueSet, int startValue) { if (valueSet == null) { return startValue; } if (valueSet.contains(startValue)) { return startValue; } SortedSet<Integer> tailSet = valueSet.tailSet(startValue + 1); if (tailSet.isEmpty()) { return -1; } else { return tailSet.first(); } } private static int getTimeYYYYMMDD(Calendar calendar) { return 10000 * calendar.get(Calendar.YEAR) + (calendar.get(Calendar.MONTH) + 1) * 100 + calendar.get(Calendar.DAY_OF_MONTH); } private static void increaseAfterDayOfMonthSpecialOp(CronOperatorEnum operator, Integer day, Integer month, boolean week, Calendar after) { DateChecker checker; if (operator == CronOperatorEnum.LASTDAY) { if (!week) { checker = new DateCheckerLastDayOfMonth(day, month); } else { if (day == null) { checker = new DateCheckerLastDayOfWeek(month); } else { checker = new DateCheckerLastSpecificDayWeek(day, month); } } } else if (operator == CronOperatorEnum.LASTWEEKDAY) { checker = new DateCheckerLastWeekday(day, month); } else { checker = new DateCheckerMonthWeekday(day, month); } int dayCount = 0; while (!checker.fits(after)) { after.add(Calendar.DAY_OF_MONTH, 1); dayCount++; if (dayCount > 10000) { throw new IllegalArgumentException("Invalid crontab expression: failed to find match day"); } } } private interface DateChecker { public boolean fits(Calendar cal); } private static class DateCheckerLastSpecificDayWeek implements DateChecker { private final int dayCode; private final Integer month; private DateCheckerLastSpecificDayWeek(int day, Integer month) { if (day < 0 || day > 7) { throw new IllegalArgumentException("Last xx day of the month has to be a day of week (0-7)"); } dayCode = DAY_OF_WEEK_ARRAY[day]; this.month = month; } public boolean fits(Calendar cal) { if (dayCode != cal.get(Calendar.DAY_OF_WEEK)) { return false; } if (month != null && month != cal.get(Calendar.MONTH)) { return false; } // e.g. 31=Sun,30=Sat,29=Fri,28=Thu,27=Wed,26=Tue,25=Mon // e.g. 31-7 = 24 return cal.get(Calendar.DAY_OF_MONTH) > cal.getActualMaximum(Calendar.DAY_OF_MONTH) - 7; } } private static class DateCheckerLastDayOfMonth implements DateChecker { private final Integer dayCode; private final Integer month; private DateCheckerLastDayOfMonth(Integer day, Integer month) { if (day != null) { if (day < 0 || day > 7) { throw new IllegalArgumentException("Last xx day of the month has to be a day of week (0-7)"); } dayCode = DAY_OF_WEEK_ARRAY[day]; } else { dayCode = null; } this.month = month; } public boolean fits(Calendar cal) { if (dayCode != null && dayCode != cal.get(Calendar.DAY_OF_WEEK)) { return false; } if (month != null && month != cal.get(Calendar.MONTH)) { return false; } return (cal.get(Calendar.DAY_OF_MONTH) == cal.getActualMaximum(Calendar.DAY_OF_MONTH)); } } private static class DateCheckerLastDayOfWeek implements DateChecker { private final Integer month; private DateCheckerLastDayOfWeek(Integer month) { this.month = month; } public boolean fits(Calendar cal) { if (month != null && month != cal.get(Calendar.MONTH)) { return false; } return (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY); } } private static class DateCheckerLastWeekday implements DateChecker { private final Integer dayCode; private final Integer month; private DateCheckerLastWeekday(Integer day, Integer month) { if (day != null) { if (day < 0 || day > 7) { throw new IllegalArgumentException("Last xx day of the month has to be a day of week (0-7)"); } dayCode = DAY_OF_WEEK_ARRAY[day]; } else { dayCode = null; } this.month = month; } public boolean fits(Calendar cal) { if (dayCode != null && dayCode != cal.get(Calendar.DAY_OF_WEEK)) { return false; } if (month != null && month != cal.get(Calendar.MONTH)) { return false; } if (!isWeekday(cal)) { return false; } int day = cal.get(Calendar.DAY_OF_MONTH); int max = cal.getActualMaximum(Calendar.DAY_OF_MONTH); if (day == max) { return true; } int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK); return day >= max - 2 && dayOfWeek == Calendar.FRIDAY; } } public static class DateCheckerMonthWeekday implements DateChecker { private final Integer day; private final Integer month; private DateCheckerMonthWeekday(Integer day, Integer month) { if (day != null) { if (day < 1 || day > 31) { throw new IllegalArgumentException("xx day of the month has to be a in range (1-31)"); } } this.day = day; this.month = month; } public boolean fits(Calendar cal) { if (month != null && month != cal.get(Calendar.MONTH)) { return false; } if (!isWeekday(cal)) { return false; } if (day == null) { return true; } Calendar work = (Calendar) cal.clone(); int target = computeNearestWeekdayDay(day, work); return cal.get(Calendar.DAY_OF_MONTH) == target; } private static int computeNearestWeekdayDay(int day, Calendar work) { int max = work.getActualMaximum(Calendar.DAY_OF_MONTH); if (day <= max) { work.set(Calendar.DAY_OF_MONTH, day); } else { work.set(Calendar.DAY_OF_MONTH, max); } if (isWeekday(work)) { return work.get(Calendar.DAY_OF_MONTH); } if (work.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY) { if (work.get(Calendar.DAY_OF_MONTH) > 1) { work.add(Calendar.DAY_OF_MONTH, -1); return work.get(Calendar.DAY_OF_MONTH); } else { work.add(Calendar.DAY_OF_MONTH, 2); return work.get(Calendar.DAY_OF_MONTH); } } else { // handle Sunday if (max == work.get(Calendar.DAY_OF_MONTH)) { work.add(Calendar.DAY_OF_MONTH, -2); return work.get(Calendar.DAY_OF_MONTH); } else { work.add(Calendar.DAY_OF_MONTH, 1); return work.get(Calendar.DAY_OF_MONTH); } } } } private static boolean isWeekday(Calendar cal) { int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK); return !(dayOfWeek < Calendar.MONDAY || dayOfWeek > Calendar.FRIDAY); } }