/*
* Copyright 2001-2009 Stephen Colebourne
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.joda.time.chrono;
import java.util.HashMap;
import java.util.Locale;
import org.joda.time.Chronology;
import org.joda.time.DateTime;
import org.joda.time.DateTimeField;
import org.joda.time.DateTimeZone;
import org.joda.time.DurationField;
import org.joda.time.MutableDateTime;
import org.joda.time.ReadableDateTime;
import org.joda.time.field.DecoratedDateTimeField;
import org.joda.time.field.DecoratedDurationField;
import org.joda.time.field.FieldUtils;
import org.joda.time.format.DateTimeFormatter;
import org.joda.time.format.ISODateTimeFormat;
/**
* Wraps another Chronology to impose limits on the range of instants that
* the fields within a Chronology may support. The limits are applied to both
* DateTimeFields and DurationFields.
* <p>
* Methods in DateTimeField and DurationField throw an IllegalArgumentException
* whenever given an input instant that is outside the limits or when an
* attempt is made to move an instant outside the limits.
* <p>
* LimitChronology is thread-safe and immutable.
*
* @author Brian S O'Neill
* @author Stephen Colebourne
* @since 1.0
*/
public final class LimitChronology extends AssembledChronology {
/** Serialization lock */
private static final long serialVersionUID = 7670866536893052522L;
/**
* Wraps another chronology, with datetime limits. When withUTC or
* withZone is called, the returned LimitChronology instance has
* the same limits, except they are time zone adjusted.
*
* @param base base chronology to wrap
* @param lowerLimit inclusive lower limit, or null if none
* @param upperLimit exclusive upper limit, or null if none
* @throws IllegalArgumentException if chronology is null or limits are invalid
*/
public static LimitChronology getInstance(Chronology base,
ReadableDateTime lowerLimit,
ReadableDateTime upperLimit) {
if (base == null) {
throw new IllegalArgumentException("Must supply a chronology");
}
lowerLimit = lowerLimit == null ? null : lowerLimit.toDateTime();
upperLimit = upperLimit == null ? null : upperLimit.toDateTime();
if (lowerLimit != null && upperLimit != null) {
if (!lowerLimit.isBefore(upperLimit)) {
throw new IllegalArgumentException
("The lower limit must be come before than the upper limit");
}
}
return new LimitChronology(base, (DateTime)lowerLimit, (DateTime)upperLimit);
}
final DateTime iLowerLimit;
final DateTime iUpperLimit;
private transient LimitChronology iWithUTC;
/**
* Wraps another chronology, with datetime limits. When withUTC or
* withZone is called, the returned LimitChronology instance has
* the same limits, except they are time zone adjusted.
*
* @param lowerLimit inclusive lower limit, or null if none
* @param upperLimit exclusive upper limit, or null if none
*/
private LimitChronology(Chronology base,
DateTime lowerLimit, DateTime upperLimit) {
super(base, null);
// These can be set after assembly.
iLowerLimit = lowerLimit;
iUpperLimit = upperLimit;
}
/**
* Returns the inclusive lower limit instant.
*
* @return lower limit
*/
public DateTime getLowerLimit() {
return iLowerLimit;
}
/**
* Returns the inclusive upper limit instant.
*
* @return upper limit
*/
public DateTime getUpperLimit() {
return iUpperLimit;
}
/**
* If this LimitChronology is already UTC, then this is
* returned. Otherwise, a new instance is returned, with the limits
* adjusted to the new time zone.
*/
public Chronology withUTC() {
return withZone(DateTimeZone.UTC);
}
/**
* If this LimitChronology has the same time zone as the one given, then
* this is returned. Otherwise, a new instance is returned, with the limits
* adjusted to the new time zone.
*/
public Chronology withZone(DateTimeZone zone) {
if (zone == null) {
zone = DateTimeZone.getDefault();
}
if (zone == getZone()) {
return this;
}
if (zone == DateTimeZone.UTC && iWithUTC != null) {
return iWithUTC;
}
DateTime lowerLimit = iLowerLimit;
if (lowerLimit != null) {
MutableDateTime mdt = lowerLimit.toMutableDateTime();
mdt.setZoneRetainFields(zone);
lowerLimit = mdt.toDateTime();
}
DateTime upperLimit = iUpperLimit;
if (upperLimit != null) {
MutableDateTime mdt = upperLimit.toMutableDateTime();
mdt.setZoneRetainFields(zone);
upperLimit = mdt.toDateTime();
}
LimitChronology chrono = getInstance
(getBase().withZone(zone), lowerLimit, upperLimit);
if (zone == DateTimeZone.UTC) {
iWithUTC = chrono;
}
return chrono;
}
public long getDateTimeMillis(int year, int monthOfYear, int dayOfMonth,
int millisOfDay)
throws IllegalArgumentException
{
long instant = getBase().getDateTimeMillis(year, monthOfYear, dayOfMonth, millisOfDay);
checkLimits(instant, "resulting");
return instant;
}
public long getDateTimeMillis(int year, int monthOfYear, int dayOfMonth,
int hourOfDay, int minuteOfHour,
int secondOfMinute, int millisOfSecond)
throws IllegalArgumentException
{
long instant = getBase().getDateTimeMillis
(year, monthOfYear, dayOfMonth,
hourOfDay, minuteOfHour, secondOfMinute, millisOfSecond);
checkLimits(instant, "resulting");
return instant;
}
public long getDateTimeMillis(long instant,
int hourOfDay, int minuteOfHour,
int secondOfMinute, int millisOfSecond)
throws IllegalArgumentException
{
checkLimits(instant, null);
instant = getBase().getDateTimeMillis
(instant, hourOfDay, minuteOfHour, secondOfMinute, millisOfSecond);
checkLimits(instant, "resulting");
return instant;
}
protected void assemble(Fields fields) {
// Keep a local cache of converted fields so as not to create redundant
// objects.
HashMap<Object, Object> converted = new HashMap<Object, Object>();
// Convert duration fields...
fields.eras = convertField(fields.eras, converted);
fields.centuries = convertField(fields.centuries, converted);
fields.years = convertField(fields.years, converted);
fields.months = convertField(fields.months, converted);
fields.weekyears = convertField(fields.weekyears, converted);
fields.weeks = convertField(fields.weeks, converted);
fields.days = convertField(fields.days, converted);
fields.halfdays = convertField(fields.halfdays, converted);
fields.hours = convertField(fields.hours, converted);
fields.minutes = convertField(fields.minutes, converted);
fields.seconds = convertField(fields.seconds, converted);
fields.millis = convertField(fields.millis, converted);
// Convert datetime fields...
fields.year = convertField(fields.year, converted);
fields.yearOfEra = convertField(fields.yearOfEra, converted);
fields.yearOfCentury = convertField(fields.yearOfCentury, converted);
fields.centuryOfEra = convertField(fields.centuryOfEra, converted);
fields.era = convertField(fields.era, converted);
fields.dayOfWeek = convertField(fields.dayOfWeek, converted);
fields.dayOfMonth = convertField(fields.dayOfMonth, converted);
fields.dayOfYear = convertField(fields.dayOfYear, converted);
fields.monthOfYear = convertField(fields.monthOfYear, converted);
fields.weekOfWeekyear = convertField(fields.weekOfWeekyear, converted);
fields.weekyear = convertField(fields.weekyear, converted);
fields.weekyearOfCentury = convertField(fields.weekyearOfCentury, converted);
fields.millisOfSecond = convertField(fields.millisOfSecond, converted);
fields.millisOfDay = convertField(fields.millisOfDay, converted);
fields.secondOfMinute = convertField(fields.secondOfMinute, converted);
fields.secondOfDay = convertField(fields.secondOfDay, converted);
fields.minuteOfHour = convertField(fields.minuteOfHour, converted);
fields.minuteOfDay = convertField(fields.minuteOfDay, converted);
fields.hourOfDay = convertField(fields.hourOfDay, converted);
fields.hourOfHalfday = convertField(fields.hourOfHalfday, converted);
fields.clockhourOfDay = convertField(fields.clockhourOfDay, converted);
fields.clockhourOfHalfday = convertField(fields.clockhourOfHalfday, converted);
fields.halfdayOfDay = convertField(fields.halfdayOfDay, converted);
}
private DurationField convertField(DurationField field, HashMap<Object, Object> converted) {
if (field == null || !field.isSupported()) {
return field;
}
if (converted.containsKey(field)) {
return (DurationField)converted.get(field);
}
LimitDurationField limitField = new LimitDurationField(field);
converted.put(field, limitField);
return limitField;
}
private DateTimeField convertField(DateTimeField field, HashMap<Object, Object> converted) {
if (field == null || !field.isSupported()) {
return field;
}
if (converted.containsKey(field)) {
return (DateTimeField)converted.get(field);
}
LimitDateTimeField limitField =
new LimitDateTimeField(field,
convertField(field.getDurationField(), converted),
convertField(field.getRangeDurationField(), converted),
convertField(field.getLeapDurationField(), converted));
converted.put(field, limitField);
return limitField;
}
void checkLimits(long instant, String desc) {
DateTime limit;
if ((limit = iLowerLimit) != null && instant < limit.getMillis()) {
throw new LimitException(desc, true);
}
if ((limit = iUpperLimit) != null && instant >= limit.getMillis()) {
throw new LimitException(desc, false);
}
}
//-----------------------------------------------------------------------
/**
* A limit chronology is only equal to a limit chronology with the
* same base chronology and limits.
*
* @param obj the object to compare to
* @return true if equal
* @since 1.4
*/
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof LimitChronology == false) {
return false;
}
LimitChronology chrono = (LimitChronology) obj;
return
getBase().equals(chrono.getBase()) &&
FieldUtils.equals(getLowerLimit(), chrono.getLowerLimit()) &&
FieldUtils.equals(getUpperLimit(), chrono.getUpperLimit());
}
/**
* A suitable hashcode for the chronology.
*
* @return the hashcode
* @since 1.4
*/
public int hashCode() {
int hash = 317351877;
hash += (getLowerLimit() != null ? getLowerLimit().hashCode() : 0);
hash += (getUpperLimit() != null ? getUpperLimit().hashCode() : 0);
hash += getBase().hashCode() * 7;
return hash;
}
/**
* A debugging string for the chronology.
*
* @return the debugging string
*/
public String toString() {
return "LimitChronology[" + getBase().toString() + ", " +
(getLowerLimit() == null ? "NoLimit" : getLowerLimit().toString()) + ", " +
(getUpperLimit() == null ? "NoLimit" : getUpperLimit().toString()) + ']';
}
//-----------------------------------------------------------------------
/**
* Extends IllegalArgumentException such that the exception message is not
* generated unless it is actually requested.
*/
private class LimitException extends IllegalArgumentException {
private static final long serialVersionUID = -5924689995607498581L;
private final boolean iIsLow;
LimitException(String desc, boolean isLow) {
super(desc);
iIsLow = isLow;
}
public String getMessage() {
StringBuffer buf = new StringBuffer(85);
buf.append("The");
String desc = super.getMessage();
if (desc != null) {
buf.append(' ');
buf.append(desc);
}
buf.append(" instant is ");
DateTimeFormatter p = ISODateTimeFormat.dateTime();
p = p.withChronology(getBase());
if (iIsLow) {
buf.append("below the supported minimum of ");
p.printTo(buf, getLowerLimit().getMillis());
} else {
buf.append("above the supported maximum of ");
p.printTo(buf, getUpperLimit().getMillis());
}
buf.append(" (");
buf.append(getBase());
buf.append(')');
return buf.toString();
}
public String toString() {
return "IllegalArgumentException: " + getMessage();
}
}
private class LimitDurationField extends DecoratedDurationField {
private static final long serialVersionUID = 8049297699408782284L;
LimitDurationField(DurationField field) {
super(field, field.getType());
}
public int getValue(long duration, long instant) {
checkLimits(instant, null);
return getWrappedField().getValue(duration, instant);
}
public long getValueAsLong(long duration, long instant) {
checkLimits(instant, null);
return getWrappedField().getValueAsLong(duration, instant);
}
public long getMillis(int value, long instant) {
checkLimits(instant, null);
return getWrappedField().getMillis(value, instant);
}
public long getMillis(long value, long instant) {
checkLimits(instant, null);
return getWrappedField().getMillis(value, instant);
}
public long add(long instant, int amount) {
checkLimits(instant, null);
long result = getWrappedField().add(instant, amount);
checkLimits(result, "resulting");
return result;
}
public long add(long instant, long amount) {
checkLimits(instant, null);
long result = getWrappedField().add(instant, amount);
checkLimits(result, "resulting");
return result;
}
public int getDifference(long minuendInstant, long subtrahendInstant) {
checkLimits(minuendInstant, "minuend");
checkLimits(subtrahendInstant, "subtrahend");
return getWrappedField().getDifference(minuendInstant, subtrahendInstant);
}
public long getDifferenceAsLong(long minuendInstant, long subtrahendInstant) {
checkLimits(minuendInstant, "minuend");
checkLimits(subtrahendInstant, "subtrahend");
return getWrappedField().getDifferenceAsLong(minuendInstant, subtrahendInstant);
}
}
private class LimitDateTimeField extends DecoratedDateTimeField {
private static final long serialVersionUID = -2435306746995699312L;
private final DurationField iDurationField;
private final DurationField iRangeDurationField;
private final DurationField iLeapDurationField;
LimitDateTimeField(DateTimeField field,
DurationField durationField,
DurationField rangeDurationField,
DurationField leapDurationField) {
super(field, field.getType());
iDurationField = durationField;
iRangeDurationField = rangeDurationField;
iLeapDurationField = leapDurationField;
}
public int get(long instant) {
checkLimits(instant, null);
return getWrappedField().get(instant);
}
public String getAsText(long instant, Locale locale) {
checkLimits(instant, null);
return getWrappedField().getAsText(instant, locale);
}
public String getAsShortText(long instant, Locale locale) {
checkLimits(instant, null);
return getWrappedField().getAsShortText(instant, locale);
}
public long add(long instant, int amount) {
checkLimits(instant, null);
long result = getWrappedField().add(instant, amount);
checkLimits(result, "resulting");
return result;
}
public long add(long instant, long amount) {
checkLimits(instant, null);
long result = getWrappedField().add(instant, amount);
checkLimits(result, "resulting");
return result;
}
public long addWrapField(long instant, int amount) {
checkLimits(instant, null);
long result = getWrappedField().addWrapField(instant, amount);
checkLimits(result, "resulting");
return result;
}
public int getDifference(long minuendInstant, long subtrahendInstant) {
checkLimits(minuendInstant, "minuend");
checkLimits(subtrahendInstant, "subtrahend");
return getWrappedField().getDifference(minuendInstant, subtrahendInstant);
}
public long getDifferenceAsLong(long minuendInstant, long subtrahendInstant) {
checkLimits(minuendInstant, "minuend");
checkLimits(subtrahendInstant, "subtrahend");
return getWrappedField().getDifferenceAsLong(minuendInstant, subtrahendInstant);
}
public long set(long instant, int value) {
checkLimits(instant, null);
long result = getWrappedField().set(instant, value);
checkLimits(result, "resulting");
return result;
}
public long set(long instant, String text, Locale locale) {
checkLimits(instant, null);
long result = getWrappedField().set(instant, text, locale);
checkLimits(result, "resulting");
return result;
}
public final DurationField getDurationField() {
return iDurationField;
}
public final DurationField getRangeDurationField() {
return iRangeDurationField;
}
public boolean isLeap(long instant) {
checkLimits(instant, null);
return getWrappedField().isLeap(instant);
}
public int getLeapAmount(long instant) {
checkLimits(instant, null);
return getWrappedField().getLeapAmount(instant);
}
public final DurationField getLeapDurationField() {
return iLeapDurationField;
}
public long roundFloor(long instant) {
checkLimits(instant, null);
long result = getWrappedField().roundFloor(instant);
checkLimits(result, "resulting");
return result;
}
public long roundCeiling(long instant) {
checkLimits(instant, null);
long result = getWrappedField().roundCeiling(instant);
checkLimits(result, "resulting");
return result;
}
public long roundHalfFloor(long instant) {
checkLimits(instant, null);
long result = getWrappedField().roundHalfFloor(instant);
checkLimits(result, "resulting");
return result;
}
public long roundHalfCeiling(long instant) {
checkLimits(instant, null);
long result = getWrappedField().roundHalfCeiling(instant);
checkLimits(result, "resulting");
return result;
}
public long roundHalfEven(long instant) {
checkLimits(instant, null);
long result = getWrappedField().roundHalfEven(instant);
checkLimits(result, "resulting");
return result;
}
public long remainder(long instant) {
checkLimits(instant, null);
long result = getWrappedField().remainder(instant);
checkLimits(result, "resulting");
return result;
}
public int getMinimumValue(long instant) {
checkLimits(instant, null);
return getWrappedField().getMinimumValue(instant);
}
public int getMaximumValue(long instant) {
checkLimits(instant, null);
return getWrappedField().getMaximumValue(instant);
}
public int getMaximumTextLength(Locale locale) {
return getWrappedField().getMaximumTextLength(locale);
}
public int getMaximumShortTextLength(Locale locale) {
return getWrappedField().getMaximumShortTextLength(locale);
}
}
}