Java 类org.joda.time.base.BaseSingleFieldPeriod 实例源码

@Override
public Object create(Object request, SpecimenContext context) {

    if (!(request instanceof SpecimenType)) {
        return new NoSpecimen();
    }

    SpecimenType type = (SpecimenType) request;
    if (!BaseSingleFieldPeriod.class.isAssignableFrom(type.getRawType())) {
        return new NoSpecimen();
    }

    Duration duration = (Duration) context.resolve(Duration.class);
    if (type.equals(Seconds.class)) return Seconds.seconds(Math.max(1, (int) duration.getStandardSeconds()));
    if (type.equals(Minutes.class)) return Minutes.minutes(Math.max(1, (int) duration.getStandardMinutes()));
    if (type.equals(Hours.class)) return Hours.hours(Math.max(1, (int) duration.getStandardHours()));

    if (type.equals(Days.class)) return Days.days(Math.max(1, (int) duration.getStandardDays()));
    if (type.equals(Weeks.class)) return Weeks.weeks(Math.max(1, (int) duration.getStandardDays() / 7));
    if (type.equals(Months.class)) return Months.months(Math.max(1, (int) duration.getStandardDays() / 30));
    if (type.equals(Years.class)) return Years.years(Math.max(1, (int) duration.getStandardDays() / 365));

    return new NoSpecimen();
}

public static Period getPeriodBetweenDates(DateTime sourceDate, DateTime targetDate,
                                           Integer periodUnit, Integer periodValue) {

    BaseSingleFieldPeriod retValue;

    if (periodUnit == null) {
        throw new SessionInternalError("Can't get a period that is null");
    }
    if (periodUnit.compareTo(Constants.PERIOD_UNIT_DAY) == 0) {
        retValue = Days.daysBetween(sourceDate, targetDate).dividedBy(periodValue).multipliedBy(periodValue);
    } else if (periodUnit.compareTo(Constants.PERIOD_UNIT_MONTH) == 0) {
        retValue = Months.monthsBetween(sourceDate, targetDate).dividedBy(periodValue).multipliedBy(periodValue);
    } else if (periodUnit.compareTo(Constants.PERIOD_UNIT_WEEK) == 0) {
        retValue = Weeks.weeksBetween(sourceDate, targetDate).dividedBy(periodValue).multipliedBy(periodValue);
    } else if (periodUnit.compareTo(Constants.PERIOD_UNIT_YEAR) == 0) {
        retValue = Years.yearsBetween(sourceDate, targetDate).dividedBy(periodValue).multipliedBy(periodValue);
    } else { // error !
        throw new SessionInternalError("Period not supported:" + periodUnit);
    }

    return retValue.toPeriod();
}

public TimeWindow(BaseSingleFieldPeriod duration, DateTime time) {
    this.windowDuration = duration;
    this.firstInstant = time;
    this.lastInstant = time;
    // get the epoch (of the first instant's time zone)
    MutableDateTime start = new MutableDateTime();
    start.setZone(time.getZone());
    start.setDate(0);
    start.setTime(0);
    this.epoch = new DateTime(start);
    this.instantSet = new BitSet(windowDuration.toPeriod().toStandardSeconds().getSeconds() / minimunSamplingIntervalInSec);

    instantSet.set((int) (new Duration(this.getTimeWindowBeginTime(), time).getStandardSeconds() / minimunSamplingIntervalInSec));
}

public BoltConfig setTimeWindowSize(BaseSingleFieldPeriod windowSize) {
    if (task instanceof TimeWindowTask) {
        ((TimeWindowTask) task).setTimeWindowSize(windowSize);
    } else {
        throw new RuntimeException(
                "Only TimeWindowTask should be assigned a window size.");
    }
    return this;
}

@Override
public int compareTo(BaseSingleFieldPeriod other) {
    if (!(other instanceof AcademicPeriod)) {
        throw new ClassCastException(getClass() + " cannot be compared to " + other.getClass());
    }

    AcademicPeriod otherAcademicPeriod = (AcademicPeriod) other;
    if (getWeight() > otherAcademicPeriod.getWeight()) {
        return -1;
    } else if (getWeight() < otherAcademicPeriod.getWeight()) {
        return 1;
    }

    return 0;
}

@Override
public boolean canHandle(Object source, TypeToken<?> targetTypeToken) {
    return targetTypeToken.isSubtypeOf(BaseSingleFieldPeriod.class)
            && ((source instanceof Number) || (stringToNumberConverter.canHandle(source, TypeToken.of(Long.class))));
}

public static int between(ReadableInstant start, ReadableInstant end, DurationFieldType field) {
    return BaseSingleFieldPeriod.between(start, end, field);
}

public static int between(ReadablePartial start, ReadablePartial end, ReadablePeriod zeroInstance) {
    return BaseSingleFieldPeriod.between(start, end, zeroInstance);
}

public static int standardPeriodIn(ReadablePeriod period, long millisPerUnit) {
    return BaseSingleFieldPeriod.standardPeriodIn(period, millisPerUnit);
}

public static int between(ReadableInstant start, ReadableInstant end, DurationFieldType field) {
    return BaseSingleFieldPeriod.between(start, end, field);
}

public static int between(ReadablePartial start, ReadablePartial end, ReadablePeriod zeroInstance) {
    return BaseSingleFieldPeriod.between(start, end, zeroInstance);
}

public static int standardPeriodIn(ReadablePeriod period, long millisPerUnit) {
    return BaseSingleFieldPeriod.standardPeriodIn(period, millisPerUnit);
}

public MovesDataCoverage(BaseSingleFieldPeriod coveragePeriod){
    this.coveragePeriod = coveragePeriod;
}

public MobilityCoverage(BaseSingleFieldPeriod period) {
    super(period);
}

protected SimpleTimeWindowTask(BaseSingleFieldPeriod timeWindowSize) {
    super(timeWindowSize);
}

public TimeWindowTask(BaseSingleFieldPeriod timeWindowSize) {
    this.timeWindowSize = timeWindowSize;
}

public void setTimeWindowSize(BaseSingleFieldPeriod timeWindowSize) {
    this.timeWindowSize = timeWindowSize;
}

public static LocalDateRange aged(final Range<? extends BaseSingleFieldPeriod> ageRange) {
    return new LocalDateRange(now().minus(ageRange.upperBound()), now().minus(ageRange.lowerBound()));
}

public static int between(ReadableInstant start, ReadableInstant end, DurationFieldType field) {
    return BaseSingleFieldPeriod.between(start, end, field);
}

public static int between(ReadablePartial start, ReadablePartial end, ReadablePeriod zeroInstance) {
    return BaseSingleFieldPeriod.between(start, end, zeroInstance);
}

public static int standardPeriodIn(ReadablePeriod period, long millisPerUnit) {
    return BaseSingleFieldPeriod.standardPeriodIn(period, millisPerUnit);
}

/**
 * Creates a <code>Minutes</code> representing the number of whole minutes
 * between the two specified partial datetimes.
 * <p>
 * The two partials must contain the same fields, for example you can specify
 * two <code>LocalTime</code> objects.
 *
 * @param start  the start partial date, must not be null
 * @param end  the end partial date, must not be null
 * @return the period in minutes
 * @throws IllegalArgumentException if the partials are null or invalid
 */
public static Minutes minutesBetween(ReadablePartial start, ReadablePartial end) {
    if (start instanceof LocalTime && end instanceof LocalTime)   {
        Chronology chrono = DateTimeUtils.getChronology(start.getChronology());
        int minutes = chrono.minutes().getDifference(
                ((LocalTime) end).getLocalMillis(), ((LocalTime) start).getLocalMillis());
        return Minutes.minutes(minutes);
    }
    int amount = BaseSingleFieldPeriod.between(start, end, ZERO);
    return Minutes.minutes(amount);
}

/**
 * Creates a <code>Minutes</code> representing the number of whole minutes
 * in the specified interval.
 *
 * @param interval  the interval to extract minutes from, null returns zero
 * @return the period in minutes
 * @throws IllegalArgumentException if the partials are null or invalid
 */
public static Minutes minutesIn(ReadableInterval interval) {
    if (interval == null)   {
        return Minutes.ZERO;
    }
    int amount = BaseSingleFieldPeriod.between(interval.getStart(), interval.getEnd(), DurationFieldType.minutes());
    return Minutes.minutes(amount);
}

/**
 * Creates a <code>Weeks</code> representing the number of whole weeks
 * between the two specified partial datetimes.
 * <p>
 * The two partials must contain the same fields, for example you can specify
 * two <code>LocalDate</code> objects.
 *
 * @param start  the start partial date, must not be null
 * @param end  the end partial date, must not be null
 * @return the period in weeks
 * @throws IllegalArgumentException if the partials are null or invalid
 */
public static Weeks weeksBetween(ReadablePartial start, ReadablePartial end) {
    if (start instanceof LocalDate && end instanceof LocalDate)   {
        Chronology chrono = DateTimeUtils.getChronology(start.getChronology());
        int weeks = chrono.weeks().getDifference(
                ((LocalDate) end).getLocalMillis(), ((LocalDate) start).getLocalMillis());
        return Weeks.weeks(weeks);
    }
    int amount = BaseSingleFieldPeriod.between(start, end, ZERO);
    return Weeks.weeks(amount);
}

/**
 * Creates a <code>Weeks</code> representing the number of whole weeks
 * in the specified interval.
 *
 * @param interval  the interval to extract weeks from, null returns zero
 * @return the period in weeks
 * @throws IllegalArgumentException if the partials are null or invalid
 */
public static Weeks weeksIn(ReadableInterval interval) {
    if (interval == null)   {
        return Weeks.ZERO;
    }
    int amount = BaseSingleFieldPeriod.between(interval.getStart(), interval.getEnd(), DurationFieldType.weeks());
    return Weeks.weeks(amount);
}

/**
 * Creates a <code>Seconds</code> representing the number of whole seconds
 * between the two specified partial datetimes.
 * <p>
 * The two partials must contain the same fields, for example you can specify
 * two <code>LocalTime</code> objects.
 *
 * @param start  the start partial date, must not be null
 * @param end  the end partial date, must not be null
 * @return the period in seconds
 * @throws IllegalArgumentException if the partials are null or invalid
 */
public static Seconds secondsBetween(ReadablePartial start, ReadablePartial end) {
    if (start instanceof LocalTime && end instanceof LocalTime)   {
        Chronology chrono = DateTimeUtils.getChronology(start.getChronology());
        int seconds = chrono.seconds().getDifference(
                ((LocalTime) end).getLocalMillis(), ((LocalTime) start).getLocalMillis());
        return Seconds.seconds(seconds);
    }
    int amount = BaseSingleFieldPeriod.between(start, end, ZERO);
    return Seconds.seconds(amount);
}

/**
 * Creates a <code>Seconds</code> representing the number of whole seconds
 * in the specified interval.
 *
 * @param interval  the interval to extract seconds from, null returns zero
 * @return the period in seconds
 * @throws IllegalArgumentException if the partials are null or invalid
 */
public static Seconds secondsIn(ReadableInterval interval) {
    if (interval == null)   {
        return Seconds.ZERO;
    }
    int amount = BaseSingleFieldPeriod.between(interval.getStart(), interval.getEnd(), DurationFieldType.seconds());
    return Seconds.seconds(amount);
}

/**
 * Creates a <code>Days</code> representing the number of whole days
 * between the two specified partial datetimes.
 * <p>
 * The two partials must contain the same fields, for example you can specify
 * two <code>LocalDate</code> objects.
 *
 * @param start  the start partial date, must not be null
 * @param end  the end partial date, must not be null
 * @return the period in days
 * @throws IllegalArgumentException if the partials are null or invalid
 */
public static Days daysBetween(ReadablePartial start, ReadablePartial end) {
    if (start instanceof LocalDate && end instanceof LocalDate)   {
        Chronology chrono = DateTimeUtils.getChronology(start.getChronology());
        int days = chrono.days().getDifference(
                ((LocalDate) end).getLocalMillis(), ((LocalDate) start).getLocalMillis());
        return Days.days(days);
    }
    int amount = BaseSingleFieldPeriod.between(start, end, ZERO);
    return Days.days(amount);
}

/**
 * Creates a <code>Days</code> representing the number of whole days
 * in the specified interval. This method corectly handles any daylight
 * savings time changes that may occur during the interval.
 *
 * @param interval  the interval to extract days from, null returns zero
 * @return the period in days
 * @throws IllegalArgumentException if the partials are null or invalid
 */
public static Days daysIn(ReadableInterval interval) {
    if (interval == null)   {
        return Days.ZERO;
    }
    int amount = BaseSingleFieldPeriod.between(interval.getStart(), interval.getEnd(), DurationFieldType.days());
    return Days.days(amount);
}

/**
 * Creates a <code>Months</code> representing the number of whole months
 * between the two specified partial datetimes.
 * <p>
 * The two partials must contain the same fields, for example you can specify
 * two <code>LocalDate</code> objects.
 *
 * @param start  the start partial date, must not be null
 * @param end  the end partial date, must not be null
 * @return the period in months
 * @throws IllegalArgumentException if the partials are null or invalid
 */
public static Months monthsBetween(ReadablePartial start, ReadablePartial end) {
    if (start instanceof LocalDate && end instanceof LocalDate)   {
        Chronology chrono = DateTimeUtils.getChronology(start.getChronology());
        int months = chrono.months().getDifference(
                ((LocalDate) end).getLocalMillis(), ((LocalDate) start).getLocalMillis());
        return Months.months(months);
    }
    int amount = BaseSingleFieldPeriod.between(start, end, ZERO);
    return Months.months(amount);
}

/**
 * Creates a <code>Months</code> representing the number of whole months
 * in the specified interval. This method corectly handles any daylight
 * savings time changes that may occur during the interval.
 *
 * @param interval  the interval to extract months from, null returns zero
 * @return the period in months
 * @throws IllegalArgumentException if the partials are null or invalid
 */
public static Months monthsIn(ReadableInterval interval) {
    if (interval == null)   {
        return Months.ZERO;
    }
    int amount = BaseSingleFieldPeriod.between(interval.getStart(), interval.getEnd(), DurationFieldType.months());
    return Months.months(amount);
}

/**
 * Creates a <code>Hours</code> representing the number of whole hours
 * between the two specified partial datetimes.
 * <p>
 * The two partials must contain the same fields, for example you can specify
 * two <code>LocalTime</code> objects.
 *
 * @param start  the start partial date, must not be null
 * @param end  the end partial date, must not be null
 * @return the period in hours
 * @throws IllegalArgumentException if the partials are null or invalid
 */
public static Hours hoursBetween(ReadablePartial start, ReadablePartial end) {
    if (start instanceof LocalTime && end instanceof LocalTime)   {
        Chronology chrono = DateTimeUtils.getChronology(start.getChronology());
        int hours = chrono.hours().getDifference(
                ((LocalTime) end).getLocalMillis(), ((LocalTime) start).getLocalMillis());
        return Hours.hours(hours);
    }
    int amount = BaseSingleFieldPeriod.between(start, end, ZERO);
    return Hours.hours(amount);
}

/**
 * Creates a <code>Hours</code> representing the number of whole hours
 * in the specified interval.
 *
 * @param interval  the interval to extract hours from, null returns zero
 * @return the period in hours
 * @throws IllegalArgumentException if the partials are null or invalid
 */
public static Hours hoursIn(ReadableInterval interval) {
    if (interval == null)   {
        return Hours.ZERO;
    }
    int amount = BaseSingleFieldPeriod.between(interval.getStart(), interval.getEnd(), DurationFieldType.hours());
    return Hours.hours(amount);
}

/**
 * Creates a <code>Years</code> representing the number of whole years
 * between the two specified partial datetimes.
 * <p>
 * The two partials must contain the same fields, for example you can specify
 * two <code>LocalDate</code> objects.
 *
 * @param start  the start partial date, must not be null
 * @param end  the end partial date, must not be null
 * @return the period in years
 * @throws IllegalArgumentException if the partials are null or invalid
 */
public static Years yearsBetween(ReadablePartial start, ReadablePartial end) {
    if (start instanceof LocalDate && end instanceof LocalDate)   {
        Chronology chrono = DateTimeUtils.getChronology(start.getChronology());
        int years = chrono.years().getDifference(
                ((LocalDate) end).getLocalMillis(), ((LocalDate) start).getLocalMillis());
        return Years.years(years);
    }
    int amount = BaseSingleFieldPeriod.between(start, end, ZERO);
    return Years.years(amount);
}

/**
 * Creates a <code>Years</code> representing the number of whole years
 * in the specified interval. This method corectly handles any daylight
 * savings time changes that may occur during the interval.
 *
 * @param interval  the interval to extract years from, null returns zero
 * @return the period in years
 * @throws IllegalArgumentException if the partials are null or invalid
 */
public static Years yearsIn(ReadableInterval interval) {
    if (interval == null)   {
        return Years.ZERO;
    }
    int amount = BaseSingleFieldPeriod.between(interval.getStart(), interval.getEnd(), DurationFieldType.years());
    return Years.years(amount);
}

/**
 * Creates a <code>Minutes</code> representing the number of whole minutes
 * between the two specified partial datetimes.
 * <p>
 * The two partials must contain the same fields, for example you can specify
 * two <code>LocalTime</code> objects.
 *
 * @param start  the start partial date, must not be null
 * @param end  the end partial date, must not be null
 * @return the period in minutes
 * @throws IllegalArgumentException if the partials are null or invalid
 */
public static Minutes minutesBetween(ReadablePartial start, ReadablePartial end) {
    if (start instanceof LocalTime && end instanceof LocalTime)   {
        Chronology chrono = DateTimeUtils.getChronology(start.getChronology());
        int minutes = chrono.minutes().getDifference(
                ((LocalTime) end).getLocalMillis(), ((LocalTime) start).getLocalMillis());
        return Minutes.minutes(minutes);
    }
    int amount = BaseSingleFieldPeriod.between(start, end, ZERO);
    return Minutes.minutes(amount);
}

/**
 * Creates a <code>Minutes</code> representing the number of whole minutes
 * in the specified interval.
 *
 * @param interval  the interval to extract minutes from, null returns zero
 * @return the period in minutes
 * @throws IllegalArgumentException if the partials are null or invalid
 */
public static Minutes minutesIn(ReadableInterval interval) {
    if (interval == null)   {
        return Minutes.ZERO;
    }
    int amount = BaseSingleFieldPeriod.between(interval.getStart(), interval.getEnd(), DurationFieldType.minutes());
    return Minutes.minutes(amount);
}

/**
 * Creates a <code>Weeks</code> representing the number of whole weeks
 * between the two specified partial datetimes.
 * <p>
 * The two partials must contain the same fields, for example you can specify
 * two <code>LocalDate</code> objects.
 *
 * @param start  the start partial date, must not be null
 * @param end  the end partial date, must not be null
 * @return the period in weeks
 * @throws IllegalArgumentException if the partials are null or invalid
 */
public static Weeks weeksBetween(ReadablePartial start, ReadablePartial end) {
    if (start instanceof LocalDate && end instanceof LocalDate)   {
        Chronology chrono = DateTimeUtils.getChronology(start.getChronology());
        int weeks = chrono.weeks().getDifference(
                ((LocalDate) end).getLocalMillis(), ((LocalDate) start).getLocalMillis());
        return Weeks.weeks(weeks);
    }
    int amount = BaseSingleFieldPeriod.between(start, end, ZERO);
    return Weeks.weeks(amount);
}

/**
 * Creates a <code>Weeks</code> representing the number of whole weeks
 * in the specified interval.
 *
 * @param interval  the interval to extract weeks from, null returns zero
 * @return the period in weeks
 * @throws IllegalArgumentException if the partials are null or invalid
 */
public static Weeks weeksIn(ReadableInterval interval) {
    if (interval == null)   {
        return Weeks.ZERO;
    }
    int amount = BaseSingleFieldPeriod.between(interval.getStart(), interval.getEnd(), DurationFieldType.weeks());
    return Weeks.weeks(amount);
}

/**
 * Creates a <code>Seconds</code> representing the number of whole seconds
 * between the two specified partial datetimes.
 * <p>
 * The two partials must contain the same fields, for example you can specify
 * two <code>LocalTime</code> objects.
 *
 * @param start  the start partial date, must not be null
 * @param end  the end partial date, must not be null
 * @return the period in seconds
 * @throws IllegalArgumentException if the partials are null or invalid
 */
public static Seconds secondsBetween(ReadablePartial start, ReadablePartial end) {
    if (start instanceof LocalTime && end instanceof LocalTime)   {
        Chronology chrono = DateTimeUtils.getChronology(start.getChronology());
        int seconds = chrono.seconds().getDifference(
                ((LocalTime) end).getLocalMillis(), ((LocalTime) start).getLocalMillis());
        return Seconds.seconds(seconds);
    }
    int amount = BaseSingleFieldPeriod.between(start, end, ZERO);
    return Seconds.seconds(amount);
}