Refine search
GregorianCalendar gc = new GregorianCalendar(); gc.add(Calendar.DATE, 1); // now do something with the calendar
/** * Returns the day of week, 'nDays' from today * * @return Calendar constant representing the day of the week */ public static int getDayOfTheWeekFromNow(int nDays) { GregorianCalendar cal = new GregorianCalendar(); cal.add(Calendar.DAY_OF_YEAR, nDays); return cal.get(Calendar.DAY_OF_WEEK); }
protected Date addSingleUnitQuantity(Date startDate, String singleUnitQuantity) { int spaceIndex = singleUnitQuantity.indexOf(" "); if (spaceIndex == -1 || singleUnitQuantity.length() < spaceIndex + 1) { throw new ActivitiIllegalArgumentException("invalid duedate format: " + singleUnitQuantity); } String quantityText = singleUnitQuantity.substring(0, spaceIndex); Integer quantity = new Integer(quantityText); String unitText = singleUnitQuantity.substring(spaceIndex + 1).trim().toLowerCase(); int unit = units.get(unitText); GregorianCalendar calendar = new GregorianCalendar(); calendar.setTime(startDate); calendar.add(unit, quantity); return calendar.getTime(); } }
public static Date getNextDateAtHour(int hour) { final GregorianCalendar now = new GregorianCalendar(); final GregorianCalendar nextDate = new GregorianCalendar(); // not truncating minutes to distribute load more evenly when multiple instances are started nextDate.set(Calendar.HOUR_OF_DAY, hour); if (nextDate.before(now)) { nextDate.add(Calendar.DAY_OF_YEAR, 1); } return nextDate.getTime(); }
Calendar cal = Calendar.getInstance(); cal.set(Calendar.YEAR, 2014); cal.set(Calendar.DAY_OF_YEAR, 1); Date start = cal.getTime(); //set date to last day of 2014 cal.set(Calendar.YEAR, 2014); cal.set(Calendar.MONTH, 11); // 11 = december cal.set(Calendar.DAY_OF_MONTH, 31); // new years eve Date end = cal.getTime(); //Iterate through the two dates GregorianCalendar gcal = new GregorianCalendar(); gcal.setTime(start); while (gcal.getTime().before(end)) { gcal.add(Calendar.DAY_OF_YEAR, 1); //Do Something ... }
/** * Reduce the size of the list by only leaving relatively new ones. * This also removes on-going builds, as RSS cannot be used to publish information * if it changes. * <em>Warning:</em> this method mutates the original list and then returns it. */ public RunList<R> newBuilds() { GregorianCalendar cal = new GregorianCalendar(); cal.add(Calendar.DAY_OF_YEAR, -7); final long t = cal.getTimeInMillis(); // can't publish on-going builds return filter(new Predicate<R>() { public boolean apply(R r) { return !r.isBuilding(); } }) // put at least 10 builds, but otherwise ignore old builds .limit(new CountingPredicate<R>() { public boolean apply(int index, R r) { return index < 10 || r.getTimeInMillis() >= t; } }); } }
/** * Given a start time, computes the next time when the wallclock will reach * a certain hour of the day, on a certain day of the week Eg: From today, * when is the next Saturday, 12PM ? * * @param startTime start time * @param targetDay day of the week to choose * @param targetHour hour of the day to choose * @return calendar object representing the target time */ public static GregorianCalendar getCalendarForNextRun(GregorianCalendar startTime, int targetDay, int targetHour) { long startTimeMs = startTime.getTimeInMillis(); GregorianCalendar cal = new GregorianCalendar(); cal.setTimeInMillis(startTimeMs); // adjust time to targetHour on startDay cal.set(Calendar.HOUR_OF_DAY, targetHour); cal.set(Calendar.MINUTE, 0); cal.set(Calendar.SECOND, 0); cal.set(Calendar.MILLISECOND, 0); // check if we are past the targetHour for the current day if(cal.get(Calendar.DAY_OF_WEEK) != targetDay || cal.getTimeInMillis() < startTimeMs) { do { cal.add(Calendar.DAY_OF_YEAR, 1); } while(cal.get(Calendar.DAY_OF_WEEK) != targetDay); } return cal; }
@Override public void updateProcessInstanceLockTime(String processInstanceId) { Date expirationTime = getClock().getCurrentTime(); int lockMillis = getAsyncExecutor().getAsyncJobLockTimeInMillis(); GregorianCalendar lockCal = new GregorianCalendar(); lockCal.setTime(expirationTime); lockCal.add(Calendar.MILLISECOND, lockMillis); Date lockDate = lockCal.getTime(); executionDataManager.updateProcessInstanceLockTime(processInstanceId, lockDate, expirationTime); }
public Date calculate(int era, int year, int month, int day, int hours, int minutes, int secs, int millisecs, boolean addOneDay, TimeZone tz) { if (calendar == null) { calendar = new GregorianCalendar(tz, Locale.US); calendar.setLenient(false); calendar.setGregorianChange(new Date(Long.MIN_VALUE)); // never use Julian calendar } else { // At least on Java 6, calendar.getTimeZone is slow due to a bug, so we need lastlySetTimeZone. if (lastlySetTimeZone != tz) { // Deliberately `!=` instead of `!<...>.equals()` calendar.setTimeZone(tz); lastlySetTimeZone = tz; } } calendar.set(Calendar.ERA, era); calendar.set(Calendar.YEAR, year); calendar.set(Calendar.MONTH, month); calendar.set(Calendar.DAY_OF_MONTH, day); calendar.set(Calendar.HOUR_OF_DAY, hours); calendar.set(Calendar.MINUTE, minutes); calendar.set(Calendar.SECOND, secs); calendar.set(Calendar.MILLISECOND, millisecs); if (addOneDay) { calendar.add(Calendar.DAY_OF_MONTH, 1); } return calendar.getTime(); }
protected void lockJob(CommandContext commandContext, JobEntity job, int lockTimeInMillis) { GregorianCalendar gregorianCalendar = new GregorianCalendar(); gregorianCalendar.setTime(commandContext.getProcessEngineConfiguration().getClock().getCurrentTime()); gregorianCalendar.add(Calendar.MILLISECOND, lockTimeInMillis); job.setLockOwner(asyncExecutor.getLockOwner()); job.setLockExpirationTime(gregorianCalendar.getTime()); } }
protected void lockJob(CommandContext commandContext, TimerJobEntity job, int lockTimeInMillis) { // This will trigger an optimistic locking exception when two concurrent executors // try to lock, as the revision will not match. GregorianCalendar gregorianCalendar = new GregorianCalendar(); gregorianCalendar.setTime(commandContext.getProcessEngineConfiguration().getClock().getCurrentTime()); gregorianCalendar.add(Calendar.MILLISECOND, lockTimeInMillis); job.setLockOwner(asyncExecutor.getLockOwner()); job.setLockExpirationTime(gregorianCalendar.getTime()); } }
GregorianCalendar calendar = new GregorianCalendar(getGMT()); calendar.setTimeInMillis(instant); calendar.set(Calendar.MONTH, iMonthOfYear - 1); calendar.set(Calendar.SECOND, 0); calendar.set(Calendar.MILLISECOND, 0); calendar.add(Calendar.MILLISECOND, iMillisOfDay); setDayOfMonthNext(calendar); calendar.add(Calendar.YEAR, 1); setDayOfMonthNext(calendar); setDayOfWeek(calendar); if (calendar.getTimeInMillis() <= instant) { calendar.add(Calendar.YEAR, 1); calendar.set(Calendar.MONTH, iMonthOfYear - 1); setDayOfMonthNext(calendar);
GregorianCalendar calendar = new GregorianCalendar(getGMT()); calendar.setTimeInMillis(instant); calendar.set(Calendar.MONTH, iMonthOfYear - 1); calendar.set(Calendar.SECOND, 0); calendar.set(Calendar.MILLISECOND, 0); calendar.add(Calendar.MILLISECOND, iMillisOfDay); setDayOfMonthPrevious(calendar); calendar.add(Calendar.YEAR, -1); setDayOfMonthPrevious(calendar); setDayOfWeek(calendar); if (calendar.getTimeInMillis() >= instant) { calendar.add(Calendar.YEAR, -1); calendar.set(Calendar.MONTH, iMonthOfYear - 1); setDayOfMonthPrevious(calendar);
protected JobEntity internalCreateLockedAsyncJob(ExecutionEntity execution, boolean exclusive) { JobEntity asyncJob = processEngineConfiguration.getJobEntityManager().create(); fillDefaultAsyncJobInfo(asyncJob, execution, exclusive); GregorianCalendar gregorianCalendar = new GregorianCalendar(); gregorianCalendar.setTime(processEngineConfiguration.getClock().getCurrentTime()); gregorianCalendar.add(Calendar.MILLISECOND, getAsyncExecutor().getAsyncJobLockTimeInMillis()); asyncJob.setLockExpirationTime(gregorianCalendar.getTime()); asyncJob.setLockOwner(getAsyncExecutor().getLockOwner()); return asyncJob; }
clientInfo, version); GregorianCalendar cal = new GregorianCalendar(); cal.add(Calendar.SECOND, intervalInSecs);
@Test public void testIsSameDay_Cal() { final GregorianCalendar cala = new GregorianCalendar(2004, 6, 9, 13, 45); final GregorianCalendar calb = new GregorianCalendar(2004, 6, 9, 13, 45); assertTrue(DateUtils.isSameDay(cala, calb)); calb.add(Calendar.DAY_OF_YEAR, 1); assertFalse(DateUtils.isSameDay(cala, calb)); cala.add(Calendar.DAY_OF_YEAR, 1); assertTrue(DateUtils.isSameDay(cala, calb)); calb.add(Calendar.YEAR, 1); assertFalse(DateUtils.isSameDay(cala, calb)); }
protected JobEntity createExecutableJobFromOtherJob(AbstractJobEntity job) { JobEntity executableJob = processEngineConfiguration.getJobEntityManager().create(); copyJobInfo(executableJob, job); if (isAsyncExecutorActive()) { GregorianCalendar gregorianCalendar = new GregorianCalendar(); gregorianCalendar.setTime(processEngineConfiguration.getClock().getCurrentTime()); gregorianCalendar.add(Calendar.MILLISECOND, getAsyncExecutor().getTimerLockTimeInMillis()); executableJob.setLockExpirationTime(gregorianCalendar.getTime()); executableJob.setLockOwner(getAsyncExecutor().getLockOwner()); } return executableJob; }
private GregorianCalendar getReferenceDate() { GregorianCalendar gregorianCalendar = new GregorianCalendar(); gregorianCalendar.add(Calendar.HOUR_OF_DAY, -1); return gregorianCalendar; }
GregorianCalendar cal = new GregorianCalendar(); cal.add(Calendar.SECOND, (int) (voldemortConfig.getSlopFrequencyMs() / Time.MS_PER_SECOND)); Date nextRun = cal.getTime();
private static Date makeExpiresDate() { GregorianCalendar gregorianCalendar = new GregorianCalendar(); gregorianCalendar.add(Calendar.DAY_OF_YEAR, 120); return gregorianCalendar.getTime(); }