/**
* 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 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);
}
/**
* 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);
}
/**
* 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 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());
}
