/**
* 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);
}
/**
* 计算两个日期之间的时间间隔(不计算毫秒数)
*
* @param date1,date2
* @param timeType
* @return int
*/
public static int periodBtDate(Date date1, Date date2, TimeType timeType) {
if (date1 == null || date2 == null) {
throw new IllegalArgumentException("date param can not be null");
}
DateTime start = fromDate(date1);
DateTime end = fromDate(date2);
int period = 0;
switch (timeType.getCode()) {
case "Y":
period = Years.yearsBetween(start, end).getYears();
break;
case "M":
period = Months.monthsBetween(start, end).getMonths();
break;
case "W":
period = Weeks.weeksBetween(start, end).getWeeks();
break;
case "D":
period = Days.daysBetween(start, end).getDays();
break;
case "H":
period = Hours.hoursBetween(start, end).getHours();
break;
case "MIN":
period = Minutes.minutesBetween(start, end).getMinutes();
break;
case "S":
period = Seconds.secondsBetween(start, end).getSeconds();
break;
default:
break;
}
return Math.abs(period);
}
/**
* Creates a new <code>Weeks</code> by parsing a string in the ISO8601 format 'PnW'.
*
* <p>The parse will accept the full ISO syntax of PnYnMnWnDTnHnMnS however only the weeks
* component may be non-zero. If any other component is non-zero, an exception will be thrown.
*
* @param periodStr the period string, null returns zero
* @return the period in weeks
* @throws IllegalArgumentException if the string format is invalid
*/
@FromString
public static Weeks parseWeeks(String periodStr) {
if (periodStr == null) {
return Weeks.ZERO;
}
Period p = PARSER.parsePeriod(periodStr);
return Weeks.weeks(p.getWeeks());
}
/**
* 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);
}
private DateTime nextRepeatWeekly(DateTime midnightNextDay) {
if (schedule.getRepeatRate() == 1) {
return midnightNextDay;
}
int distanceBetweenStartAndTomorrow =
Weeks.weeksBetween(new DateTime(schedule.getBeginDate()).toDateMidnight(), midnightNextDay)
.getWeeks();
if (distanceBetweenStartAndTomorrow == 0
|| distanceBetweenStartAndTomorrow == schedule.getRepeatRate()) {
if ((distanceBetweenStartAndTomorrow == 0
&& midnightNextDay.getDayOfWeek()
<= new DateMidnight(schedule.getBeginDate()).getDayOfWeek())) {
// we crossed a week boundary, so add one week.
return midnightNextDay.plusWeeks(schedule.getRepeatRate() - 1);
}
return midnightNextDay;
} else if (distanceBetweenStartAndTomorrow > schedule.getRepeatRate()) {
int remainder = distanceBetweenStartAndTomorrow % schedule.getRepeatRate();
return midnightNextDay.plusWeeks(schedule.getRepeatRate() - remainder);
} else {
return midnightNextDay.plusWeeks(schedule.getRepeatRate() - distanceBetweenStartAndTomorrow);
}
}
/**
* Creates a <code>Weeks</code> representing the number of whole weeks between the two specified
* datetimes.
*
* @param start the start instant, must not be null
* @param end the end instant, must not be null
* @return the period in weeks
* @throws IllegalArgumentException if the instants are null or invalid
*/
public static Weeks weeksBetween(ReadableInstant start, ReadableInstant end) {
int amount = BaseSingleFieldPeriod.between(start, end, DurationFieldType.weeks());
return Weeks.weeks(amount);
}
/**
* Is this weeks instance less than the specified number of weeks.
*
* @param other the other period, null means zero
* @return true if this weeks instance is less than the specified one
*/
public boolean isLessThan(Weeks other) {
if (other == null) {
return getValue() < 0;
}
return getValue() < other.getValue();
}
/**
* Is this weeks instance greater than the specified number of weeks.
*
* @param other the other period, null means zero
* @return true if this weeks instance is greater than the specified one
*/
public boolean isGreaterThan(Weeks other) {
if (other == null) {
return getValue() > 0;
}
return getValue() > other.getValue();
}
/**
* Returns a new instance with the weeks value negated.
*
* @return the new period with a negated value
* @throws ArithmeticException if the result overflows an int
*/
public Weeks negated() {
return Weeks.weeks(FieldUtils.safeNegate(getValue()));
}
/**
* Returns a new instance with the weeks divided by the specified divisor. The calculation uses
* integer division, thus 3 divided by 2 is 1.
*
* <p>This instance is immutable and unaffected by this method call.
*
* @param divisor the amount to divide by, may be negative
* @return the new period divided by the specified divisor
* @throws ArithmeticException if the divisor is zero
*/
public Weeks dividedBy(int divisor) {
if (divisor == 1) {
return this;
}
return Weeks.weeks(getValue() / divisor);
}
/**
* Returns a new instance with the weeks multiplied by the specified scalar.
*
* <p>This instance is immutable and unaffected by this method call.
*
* @param scalar the amount to multiply by, may be negative
* @return the new period multiplied by the specified scalar
* @throws ArithmeticException if the result overflows an int
*/
public Weeks multipliedBy(int scalar) {
return Weeks.weeks(FieldUtils.safeMultiply(getValue(), scalar));
}
/**
* Returns a new instance with the specified number of weeks taken away.
*
* <p>This instance is immutable and unaffected by this method call.
*
* @param weeks the amount of weeks to take away, may be negative, null means zero
* @return the new period minus the specified number of weeks
* @throws ArithmeticException if the result overflows an int
*/
public Weeks minus(Weeks weeks) {
if (weeks == null) {
return this;
}
return minus(weeks.getValue());
}
/**
* Returns a new instance with the specified number of weeks added.
*
* <p>This instance is immutable and unaffected by this method call.
*
* @param weeks the amount of weeks to add, may be negative
* @return the new period plus the specified number of weeks
* @throws ArithmeticException if the result overflows an int
*/
public Weeks plus(int weeks) {
if (weeks == 0) {
return this;
}
return Weeks.weeks(FieldUtils.safeAdd(getValue(), weeks));
}
/**
* Resolves singletons.
*
* @return the singleton instance
*/
private Object readResolve() {
return Weeks.weeks(getValue());
}
/**
* Creates a new <code>Weeks</code> representing the number of complete standard length weeks in
* the specified period.
*
* <p>This factory method converts all fields from the period to hours using standardised
* durations for each field. Only those fields which have a precise duration in the ISO UTC
* chronology can be converted.
*
* <ul>
* <li>One week consists of 7 days.
* <li>One day consists of 24 hours.
* <li>One hour consists of 60 minutes.
* <li>One minute consists of 60 weeks.
* <li>One second consists of 1000 milliseconds.
* </ul>
*
* Months and Years are imprecise and periods containing these values cannot be converted.
*
* @param period the period to get the number of hours from, null returns zero
* @return the period in weeks
* @throws IllegalArgumentException if the period contains imprecise duration values
*/
public static Weeks standardWeeksIn(ReadablePeriod period) {
int amount = BaseSingleFieldPeriod.standardPeriodIn(period, DateTimeConstants.MILLIS_PER_WEEK);
return Weeks.weeks(amount);
}
// -----------------------------------------------------------------------
public void testToStandardWeeks() {
Minutes test = Minutes.minutes(60 * 24 * 7 * 2);
Weeks expected = Weeks.weeks(2);
assertEquals(expected, test.toStandardWeeks());
}