@VisibleForTesting static double convert(double value, TimeUnit from, TimeUnit target) { if (target.compareTo(from) > 0) { return value / from.convert(1, target); } return value * target.convert(1, from); }
@NonNull @Override public Disposable schedule(@NonNull final Runnable action, final long delayTime, @NonNull final TimeUnit delayUnit) { TimeUnit common = delayUnit.compareTo(unit) < 0 ? delayUnit : unit; long t = common.convert(delayTime, delayUnit) + common.convert(delay, unit); return actualInner.schedule(action, t, common); }
@NonNull @Override public Disposable schedule(@NonNull final Runnable action, final long delayTime, @NonNull final TimeUnit delayUnit) { TimeUnit common = delayUnit.compareTo(unit) < 0 ? delayUnit : unit; long t = common.convert(delayTime, delayUnit) + common.convert(delay, unit); return actualInner.schedule(action, t, common); }
if (receiver.get().compareTo(convertTo) < 0) {
public static long roundFromMillis(long millis, TimeUnit units) { if (units.compareTo(TimeUnit.MILLISECONDS) > 0) { double result = ((double)millis) / units.toMillis(1); return Math.round(result); } else { return units.convert(millis, TimeUnit.MILLISECONDS); } }
public static long roundFromMillis(long millis, TimeUnit units) { if (units.compareTo(TimeUnit.MILLISECONDS) > 0) { double result = ((double)millis) / units.toMillis(1); return Math.round(result); } else { return units.convert(millis, TimeUnit.MILLISECONDS); } }
/** Returns the current average rate as a primitive value. */ private long getPrimitive() { final double inMillis = avg.getPrimitive(); if (reportTimeUnit == MILLISECONDS) { return Math.round(inMillis); } else if (reportTimeUnit.compareTo(MILLISECONDS) < 0) { return Math.round( inMillis / reportTimeUnit.convert(1, MILLISECONDS)); } else { return Math.round(inMillis * reportTimeUnit.toMillis(1)); } }
public static TimeUnit displayUnitFor(long duration, TimeUnit units) { if (units == NANOSECONDS && duration < MICROSECONDS.toNanos(2)) { return NANOSECONDS; } if (units.toMicros(duration) < MILLISECONDS.toMicros(2) && units.compareTo(MICROSECONDS) <= 0) { return MICROSECONDS; } long durationInMillis = units.toMillis(duration); if (durationInMillis < SECONDS.toMillis(2) && units.compareTo(MILLISECONDS) <= 0) { return MILLISECONDS; } else if (durationInMillis < MINUTES.toMillis(2) && units.compareTo(SECONDS) <= 0) { return SECONDS; } else if (durationInMillis < HOURS.toMillis(2) && units.compareTo(MINUTES) <= 0) { return MINUTES; } else if (durationInMillis < DAYS.toMillis(2) && units.compareTo(HOURS) <= 0) { return HOURS; } else { return DAYS; } }
@Override public int compareTo(TimeDuration that) { if (this.unit.compareTo(that.unit) > 0) { return that.compareTo(this); } // this.unit <= that.unit final long thisDurationInThatUnit = that.unit.convert(this.duration, this.unit); if (thisDurationInThatUnit == that.duration) { final long thatDurationInThisUnit = this.unit.convert(that.duration, that.unit); return Long.compare(this.duration, thatDurationInThisUnit); } else { return Long.compare(thisDurationInThatUnit, that.duration); } }
public TimeMeasure plus(TimeMeasure o) { return unit.compareTo(o.unit) < 0 ? new TimeMeasure(value + unit.convert(o.value, o.unit), unit) : new TimeMeasure(o.value + o.unit.convert(value, unit), o.unit); }
final int unitCompare = timeUnit.compareTo(o.timeUnit); if (unitCompare == 0) { if (this.value < o.value) {
@Override public int compare(TimeBucket timeBucketA, TimeBucket timeBucketB) { return timeBucketA.getTimeUnit().compareTo(timeBucketB.getTimeUnit()); } }
public AlignedPeriodicSchedule(long alignment, TimeUnit alignmentUnit, long period, TimeUnit periodUnit) { super(period, periodUnit); if (alignment < 1) throw new AlignmentOfLessThanOneIsMeaninglessException(alignment); if (alignmentUnit.compareTo(periodUnit) > 0) throw new AlignmentCannotBeLessThanPeriodUnitsException(alignmentUnit, periodUnit); if (alignment > alignmentUnit.convert(period, periodUnit)) throw new AlignmentMustBeLessThanPeriodException(alignment, alignmentUnit, period, periodUnit); this.alignment = alignment; this.alignmentUnit = alignmentUnit; }
@Override public int compareTo(TimeDuration that) { if (this.unit.compareTo(that.unit) > 0) { return that.compareTo(this); } if (this.unit == that.unit) { return Long.compare(this.duration, that.duration); } // this.unit < that.unit final long thisDurationInThatUnit = this.toLong(that.unit); if (thisDurationInThatUnit == that.duration) { // check for overflow final long thatDurationInThisUnit = that.toLong(this.unit); return Long.compare(this.duration, thatDurationInThisUnit); } else { return Long.compare(thisDurationInThatUnit, that.duration); } }
@Override public Schedule parse(String specification) { Matcher match = alignedPeriodic.matcher(specification); if (!match.matches()) throw new IllegalStateException("The schedule specification must match if matches was called"); long period = parseNumber(match.group(1)); TimeUnit periodUnit = parseTimeUnit(match.group(2)); if (TimeUnit.NANOSECONDS.equals(periodUnit)) throw new UnsupportedUnitForSchedulingException(periodUnit); TimeUnit derivedAlignmentUnit = deriveAlignment(periodUnit); TimeUnit alignmentUnit = parseTimeUnit(match.group(4)); if (alignmentUnit.compareTo(periodUnit) > 0) throw new AlignmentCannotBeLessThanPeriodUnitsException(alignmentUnit, periodUnit); long alignment = derivedAlignmentUnit.convert(Long.valueOf(match.group(3)), alignmentUnit); return new AlignedPeriodicSchedule(alignment, derivedAlignmentUnit, period, periodUnit); }
if(TimeUnit.SECONDS.compareTo(this.queryTimeoutUnit) > 0 && this.queryTimeout % 1000 > 0){ timeout += 1;
@NonNull @Override public Disposable schedule(@NonNull final Runnable action, final long delayTime, @NonNull final TimeUnit delayUnit) { TimeUnit common = delayUnit.compareTo(unit) < 0 ? delayUnit : unit; long t = common.convert(delayTime, delayUnit) + common.convert(delay, unit); return actualInner.schedule(action, t, common); }
@NonNull @Override public Disposable schedule(@NonNull final Runnable action, final long delayTime, @NonNull final TimeUnit delayUnit) { TimeUnit common = delayUnit.compareTo(unit) < 0 ? delayUnit : unit; long t = common.convert(delayTime, delayUnit) + common.convert(delay, unit); return actualInner.schedule(action, t, common); }
) { if (unit.compareTo(TimeUnit.SECONDS) >= 0) { long secs = Math.multiplyExact(
@Override public Moment addTo( Moment context, long amount ) { if (this.unit.compareTo(TimeUnit.SECONDS) >= 0) { long secs = Math.multiplyExact(amount, this.unit.toSeconds(1)); return Moment.of( Math.addExact(context.getPosixTime(), secs), context.getNanosecond(), POSIX ); } else { // MILLIS, MICROS, NANOS long nanos = Math.multiplyExact(amount, this.unit.toNanos(1)); long sum = Math.addExact(context.getNanosecond(), nanos); int nano = (int) Math.floorMod(sum, MRD); long second = Math.floorDiv(sum, MRD); return Moment.of( Math.addExact(context.getPosixTime(), second), nano, POSIX ); } }