/** * Find the current instance based on effectiveTime (i.e Action_Creation_Time or * Action_Start_Time) * * @return current instance i.e. current(0) returns null if effectiveTime is earlier than Initial * Instance time of the dataset. */ private static Calendar getCurrentInstance(Date effectiveTime, int instanceCount[]) { Date datasetInitialInstance = getInitialInstance(); TimeUnit dsTimeUnit = getDSTimeUnit(); TimeZone dsTZ = getDatasetTZ(); // Convert Date to Calendar for corresponding TZ Calendar current = Calendar.getInstance(); current.setTime(datasetInitialInstance); current.setTimeZone(dsTZ); Calendar calEffectiveTime = Calendar.getInstance(); calEffectiveTime.setTime(effectiveTime); calEffectiveTime.setTimeZone(dsTZ); instanceCount[0] = 0; if (current.compareTo(calEffectiveTime) > 0) { // Nominal Time < initial Instance // TODO: getClass() call doesn't work from static method. // XLog.getLog("CoordELFunction.class").warn("ACTION CREATED BEFORE INITIAL INSTACE "+ // current.getTime()); return null; } Calendar origCurrent = (Calendar) current.clone(); while (current.compareTo(calEffectiveTime) <= 0) { current = (Calendar) origCurrent.clone(); instanceCount[0]++; current.add(dsTimeUnit.getCalendarUnit(), instanceCount[0] * getDSFrequency()); } instanceCount[0]--; current = (Calendar) origCurrent.clone(); current.add(dsTimeUnit.getCalendarUnit(), instanceCount[0] * getDSFrequency()); return current; }
public TimeUnit deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException { String unit = json.getAsString(); TimeUnit tu; try { tu = TimeUnit.from(unit); } catch (IllegalArgumentException e) { throw new ContextualJsonSyntaxException( unit, "is not a valid time unit, must be one of " + TimeUnit.toValueNames()); } return tu; }
/** * Returns the a date string while given a base date in 'strBaseDate', offset and unit (e.g. DAY, * MONTH, HOUR, MINUTE, MONTH). * * @param strBaseDate -- base date * @param offset -- any number * @param unit -- DAY, MONTH, HOUR, MINUTE, MONTH * @return date string * @throws Exception */ public static String ph2_coord_dateOffset(String strBaseDate, int offset, String unit) throws Exception { Calendar baseCalDate = DateUtils.getCalendar(strBaseDate); StringBuilder buffer = new StringBuilder(); baseCalDate.add(TimeUnit.valueOf(unit).getCalendarUnit(), offset); buffer.append(DateUtils.formatDateUTC(baseCalDate)); return buffer.toString(); }
/** * @param n * @return n-th instance Date-Time from current instance for data-set * <p>return empty string ("") if the Action_Creation_time or the n-th instance * <p>is earlier than the Initial_Instance of dataset. * @throws Exception */ private static String coord_current_sync(int n) throws Exception { int datasetFrequency = getDSFrequency(); // in minutes TimeUnit dsTimeUnit = getDSTimeUnit(); int[] instCount = new int[1]; // used as pass by ref Calendar nominalInstanceCal = getCurrentInstance(getActionCreationtime(), instCount); if (nominalInstanceCal == null) { return ""; } nominalInstanceCal = getInitialInstanceCal(); int absInstanceCount = instCount[0] + n; nominalInstanceCal.add(dsTimeUnit.getCalendarUnit(), datasetFrequency * absInstanceCount); if (nominalInstanceCal.getTime().compareTo(getInitialInstance()) < 0) { return ""; } String str = DateUtils.formatDateUTC(nominalInstanceCal); return str; }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ public TimeUnit createTimeUnitFromString(EDataType eDataType, String initialValue) { TimeUnit result = TimeUnit.get(initialValue); if (result == null) throw new IllegalArgumentException( "The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); return result; }
private void calculateBarLeft(Date plannedStartTime, long startingPoint) { // Calendar c = Calendar.getInstance(); // c.setTimeInMillis(startingPoint); // // c.set(Calendar.MINUTE, 0); // c.set(Calendar.SECOND, 0); // c.set(Calendar.MILLISECOND, 0); Calendar calculatedStartDate = timeUnit.calculateStartDate(startingPoint); long difference = plannedStartTime.getTime() - calculatedStartDate.getTimeInMillis(); this.barLeft = new Long(difference / 1000 / 60).intValue(); }
private void calculateProgressLeft(long startTime, long startingPoint) { if (startTime == 0) { this.progressLeft = this.barLeft; } else { // Calendar c = Calendar.getInstance(); // c.setTimeInMillis(startingPoint); // // c.set(Calendar.MINUTE, 0); // c.set(Calendar.SECOND, 0); // c.set(Calendar.MILLISECOND, 0); Calendar calculatedStartDate = timeUnit.calculateStartDate(startingPoint); long difference = startTime - calculatedStartDate.getTimeInMillis(); progressLeft = new BigDecimal(difference) .divide(new BigDecimal(1000), 2, BigDecimal.ROUND_HALF_UP) .divide(new BigDecimal(60), 2, BigDecimal.ROUND_HALF_UP) .doubleValue(); } }
/** * @param offset * @return n-th available latest instance Date-Time for SYNC data-set * @throws Exception */ private static String coord_latest_sync(int offset) throws Exception { if (offset > 0) { throw new RuntimeException( "For latest there is no meaning " + "of positive instance. n should be <=0" + offset); } ELEvaluator eval = ELEvaluator.getCurrent(); String retVal = ""; int datasetFrequency = (int) getDSFrequency(); // in minutes TimeUnit dsTimeUnit = getDSTimeUnit(); int[] instCount = new int[1]; Calendar nominalInstanceCal = getCurrentInstance(getActualTime(), instCount); if (nominalInstanceCal != null) { Calendar initInstance = getInitialInstanceCal(); SyncCoordDataset ds = (SyncCoordDataset) eval.getVariable(DATASET); if (ds == null) { throw new RuntimeException("Associated Dataset should be defined with key " + DATASET); } String uriTemplate = ds.getUriTemplate(); Configuration conf = (Configuration) eval.getVariable(CONFIGURATION); if (conf == null) { throw new RuntimeException( "Associated Configuration should be defined with key " + CONFIGURATION); } int available = 0; boolean resolved = false; String user = ParamChecker.notEmpty( (String) eval.getVariable(OozieClient.USER_NAME), OozieClient.USER_NAME); String group = ParamChecker.notEmpty( (String) eval.getVariable(OozieClient.GROUP_NAME), OozieClient.GROUP_NAME); String doneFlag = ds.getDoneFlag(); while (nominalInstanceCal.compareTo(initInstance) >= 0) { ELEvaluator uriEval = getUriEvaluator(nominalInstanceCal); String uriPath = uriEval.evaluate(uriTemplate, String.class); String pathWithDoneFlag = uriPath; if (doneFlag.length() > 0) { pathWithDoneFlag += "/" + doneFlag; } if (isPathAvailable(pathWithDoneFlag, user, group, conf)) { XLog.getLog(CoordELFunctions.class) .debug("Found latest(" + available + "): " + pathWithDoneFlag); if (available == offset) { XLog.getLog(CoordELFunctions.class).debug("Found Latest File: " + pathWithDoneFlag); resolved = true; retVal = DateUtils.formatDateUTC(nominalInstanceCal); eval.setVariable("resolved_path", uriPath); break; } available--; } // nominalInstanceCal.add(dsTimeUnit.getCalendarUnit(), // -datasetFrequency); nominalInstanceCal = (Calendar) initInstance.clone(); instCount[0]--; nominalInstanceCal.add(dsTimeUnit.getCalendarUnit(), instCount[0] * datasetFrequency); // DateUtils.moveToEnd(nominalInstanceCal, getDSEndOfFlag()); } if (!resolved) { // return unchanged latest function with variable 'is_resolved' // to 'false' eval.setVariable("is_resolved", Boolean.FALSE); retVal = "${coord:latest(" + offset + ")}"; } else { eval.setVariable("is_resolved", Boolean.TRUE); } } else { // No feasible nominal time eval.setVariable("is_resolved", Boolean.FALSE); } return retVal; }
public int getDurationWidth() { return timeUnit.calculateSize(durationWidth); }
@Override public void writeToParcel(Parcel dest, int flags) { dest.writeInt(timeInterval); dest.writeInt(timeUnit.ordinal()); }
private Duration(Parcel in) { timeInterval = in.readInt(); timeUnit = TimeUnit.values()[in.readInt()]; }
public static Long convertTime(Long time, TimeUnit from, TimeUnit to) { return (time == null) ? null : new Long((time.longValue() * from.getFactor()) / to.getFactor()); }
public String format() { return units.formatFull(dateTime.getMillis()); }
public RoughTime plus(TimeUnit unit, int times) { RoughTime r = copy(); unit.addTo(r, times); return r; }
public void calculateDiagramBars() { long startTime = instance != null ? instance.getStartTime().getTime() : 0; // calculate status and color this.calculateStatus(model, instance, predecessor); if (model.getPlannedStartTime() != null && model.getPlannedTerminationTime() != null) { // calculate barWidth this.calculateBarWidth(model.getPlannedStartTime(), model.getPlannedTerminationTime()); // calculate barLeft this.calculateBarLeft(model.getPlannedStartTime(), startingPoint); } // calculate progressLeft this.calculateProgressLeft(startTime, startingPoint); // calculate progressWidth Calendar calculatedStartDate = timeUnit.calculateStartDate(startingPoint); this.progressWidth = 0; long duration = instance != null ? instance.getDuration() : 0; if (instance != null) { if (instance.getTerminationTime() != null) { this.progressWidth = new BigDecimal(new Long(duration).doubleValue()) .divide(new BigDecimal(1000), BigDecimal.ROUND_HALF_UP) .divide(new BigDecimal(60), BigDecimal.ROUND_HALF_UP) .intValue(); } else { BigDecimal nowBD = new BigDecimal( new Long(timeProvider.getCurrentTime() - calculatedStartDate.getTimeInMillis()) .doubleValue()); double nowInTimeUnit = nowBD .divide(new BigDecimal(1000), 1, BigDecimal.ROUND_HALF_UP) .divide(new BigDecimal(60), 1, BigDecimal.ROUND_HALF_UP) .doubleValue(); this.progressWidth = timeUnit.calculateSize(nowInTimeUnit) - getProgressLeft(); } } if (model.getEstimatedDuration() != 0) { // calculate progress this.calculateProgress(duration, model.getEstimatedDuration()); progressCalculated = true; } this.calculateIconStatus(instance); // calculate durationWidth this.durationWidth = new Long(model.getEstimatedDuration()).intValue() / 1000 / 60; if (model.getSuccessorId() != null && !"".equals(model.getSuccessorId())) { this.dependencyHeight = 0; // this.dependencyWidth = 1; } // completed process instance if (instance != null && instance.getTerminationTime() != null) { this.completed = "background-color: #EEEFF7;"; // this.durationWidth = 0; // this.barWidth = 0; // this.progressColor = this.color; } }
public long convert(long d, TimeUnit u) { return u.toHours(d); }
public long convert(long d, TimeUnit u) { return u.toSeconds(d); }
public int getProgressLeft() { return timeUnit.calculateSize(progressLeft); }
public int getBarLeft() { return timeUnit.calculateSize(barLeft); }
public int getBarWidth() { return timeUnit.calculateSize(barWidth); }
public long convert(long d, TimeUnit u) { return u.toMinutes(d); }
/** * Acquires the lock if it is not held by another thread within the given waiting time and the * current thread has not been {@link Thread#interrupt interrupted}. * * <p>Acquires the lock if it is not held by another thread and returns immediately with the value * <tt>true</tt>, setting the lock hold count to one. If this lock has been set to use a fair * ordering policy then an available lock <em>will not</em> be acquired if any other threads are * waiting for the lock. This is in contrast to the {@link #tryLock()} method. If you want a timed * <tt>tryLock</tt> that does permit barging on a fair lock then combine the timed and un-timed * forms together: * * <pre>if (lock.tryLock() || lock.tryLock(timeout, unit) ) { ... } * </pre> * * <p>If the current thread already holds this lock then the hold count is incremented by one and * the method returns <tt>true</tt>. * * <p>If the lock is held by another thread then the current thread becomes disabled for thread * scheduling purposes and lies dormant until one of three things happens: * * <ul> * <li>The lock is acquired by the current thread; or * <li>Some other thread {@link Thread#interrupt interrupts} the current thread; or * <li>The specified waiting time elapses * </ul> * * <p>If the lock is acquired then the value <tt>true</tt> is returned and the lock hold count is * set to one. * * <p>If the current thread: * * <ul> * <li>has its interrupted status set on entry to this method; or * <li>is {@link Thread#interrupt interrupted} while acquiring the lock, * </ul> * * then {@link InterruptedException} is thrown and the current thread's interrupted status is * cleared. * * <p>If the specified waiting time elapses then the value <tt>false</tt> is returned. If the time * is less than or equal to zero, the method will not wait at all. * * <p>In this implementation, as this method is an explicit interruption point, preference is * given to responding to the interrupt over normal or reentrant acquisition of the lock, and over * reporting the elapse of the waiting time. * * @param timeout the time to wait for the lock * @param unit the time unit of the timeout argument * @return <tt>true</tt> if the lock was free and was acquired by the current thread, or the lock * was already held by the current thread; and <tt>false</tt> if the waiting time elapsed * before the lock could be acquired. * @throws InterruptedException if the current thread is interrupted * @throws NullPointerException if unit is null */ public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException { return sync.tryLock(unit.toNanos(timeout)); }
public long convert(long d, TimeUnit u) { return u.toNanos(d); }
public class Chronometer { //////////////////////////////////////////////////////////////////////////// // ATTRIBUTE(S) //////////////////////////////////////////////////////////////////////////// // Time units public static final int N_TIME_UNITS = TimeUnit.values().length; // Information of the chronometer private final long[] time = new long[N_TIME_UNITS]; private final double[] timeByUnit = new double[N_TIME_UNITS]; private long begin = 0L, end = 0L; private Long difference = 0L; private String representation = Strings.EMPTY; //////////////////////////////////////////////////////////////////////////// // CONSTRUCTOR(S) //////////////////////////////////////////////////////////////////////////// public Chronometer() {} //////////////////////////////////////////////////////////////////////////// // CHRONOMETER //////////////////////////////////////////////////////////////////////////// public void start() { begin = System.currentTimeMillis(); } public Long stop() { end = System.currentTimeMillis(); compute(); return difference; } private void compute() { difference = end - begin; timeByUnit[0] = difference; time[0] = (long) (timeByUnit[0] % 1000); for (int i = 1; i < N_TIME_UNITS; ++i) { timeByUnit[i] = difference / (1000. * Math.pow(60, i - 1)); time[i] = (long) (timeByUnit[i] % 60); } representation = time[TimeUnit.HOUR.index] + ":" + time[TimeUnit.MINUTE.index] + ":" + time[TimeUnit.SECOND.index] + "." + time[TimeUnit.MILLISECOND.index]; } public long getMilliseconds() { return difference; } public double getSeconds() { return timeByUnit[TimeUnit.SECOND.index]; } public double getMinutes() { return timeByUnit[TimeUnit.MINUTE.index]; } public double getHours() { return timeByUnit[TimeUnit.HOUR.index]; } public void setValue(final long value) { begin = 0; end = value; compute(); } //////////////////////////////////////////////////////////////////////////// // OBJECT //////////////////////////////////////////////////////////////////////////// @Override public String toString() { return representation; } //////////////////////////////////////////////////////////////////////////// // ENUM(S) //////////////////////////////////////////////////////////////////////////// public enum TimeUnit { MILLISECOND(0), SECOND(1), MINUTE(2), HOUR(3); public int index; private TimeUnit(final int index) { this.index = index; } } }