| /* |
| ******************************************************************************* |
| * Copyright (C) 2007-2008, International Business Machines Corporation and * |
| * others. All Rights Reserved. * |
| ******************************************************************************* |
| */ |
| package com.ibm.icu.util; |
| |
| import java.util.BitSet; |
| import java.util.Date; |
| import java.util.LinkedList; |
| import java.util.List; |
| |
| import com.ibm.icu.impl.Grego; |
| |
| /** |
| * <code>BasicTimeZone</code> is an abstract class extending <code>TimeZone</code>. |
| * This class provides some additional methods to access time zone transitions |
| * and rules. All ICU <code>TimeZone</code> concrete subclasses extend this |
| * class. |
| * |
| * @see com.ibm.icu.util.TimeZoneRule |
| * @see com.ibm.icu.util.TimeZoneTransition |
| * |
| * @stable ICU 3.8 |
| */ |
| public abstract class BasicTimeZone extends TimeZone { |
| |
| private static final long serialVersionUID = -3204278532246180932L; |
| |
| private static final long MILLIS_PER_YEAR = 365*24*60*60*1000L; |
| |
| /** |
| * Gets the first time zone transition after the base time. |
| * |
| * @param base The base time. |
| * @param inclusive Whether the base time is inclusive or not. |
| * |
| * @return A <code>Date</code> holding the first time zone transition time |
| * after the given base time, or null if no time zone transitions |
| * are available after the base time. |
| * |
| * @stable ICU 3.8 |
| */ |
| public abstract TimeZoneTransition getNextTransition(long base, boolean inclusive); |
| |
| /** |
| * Gets the last time zone transition before the base time. |
| * |
| * @param base The base time. |
| * @param inclusive Whether the base time is inclusive or not. |
| * |
| * @return A <code>Date</code> holding the last time zone transition time |
| * before the given base time, or null if no time zone transitions |
| * are available before the base time. |
| * |
| * @stable ICU 3.8 |
| */ |
| public abstract TimeZoneTransition getPreviousTransition(long base, boolean inclusive); |
| |
| /** |
| * Checks if the time zone has equivalent transitions in the time range. |
| * This method returns true when all of transition times, from/to standard |
| * offsets and DST savings used by this time zone match the other in the |
| * time range. |
| * |
| * @param tz The instance of <code>TimeZone</code> |
| * @param start The start time of the evaluated time range (inclusive) |
| * @param end The end time of the evaluated time range (inclusive) |
| * |
| * @return true if the other time zone has the equivalent transitions in the |
| * time range. When tz is not a <code>BasicTimeZone</code>, this method |
| * returns false. |
| * |
| * @stable ICU 3.8 |
| */ |
| public boolean hasEquivalentTransitions(TimeZone tz, long start, long end) { |
| return hasEquivalentTransitions(tz, start, end, false); |
| } |
| |
| /** |
| * Checks if the time zone has equivalent transitions in the time range. |
| * This method returns true when all of transition times, from/to standard |
| * offsets and DST savings used by this time zone match the other in the |
| * time range. |
| * |
| * @param tz The instance of <code>TimeZone</code> |
| * @param start The start time of the evaluated time range (inclusive) |
| * @param end The end time of the evaluated time range (inclusive) |
| * @param ignoreDstAmount |
| * When true, any transitions with only daylight saving amount |
| * changes will be ignored, except either of them is zero. |
| * For example, a transition from rawoffset 3:00/dstsavings 1:00 |
| * to rawoffset 2:00/dstsavings 2:00 is excluded from the comparison, |
| * but a transtion from rawoffset 2:00/dstsavings 1:00 to |
| * rawoffset 3:00/dstsavings 0:00 is included. |
| * |
| * @return true if the other time zone has the equivalent transitions in the |
| * time range. When tz is not a <code>BasicTimeZone</code>, this method |
| * returns false. |
| * |
| * @stable ICU 3.8 |
| */ |
| public boolean hasEquivalentTransitions(TimeZone tz, long start, long end, boolean ignoreDstAmount) { |
| if (hasSameRules(tz)) { |
| return true; |
| } |
| if (!(tz instanceof BasicTimeZone)) { |
| return false; |
| } |
| |
| // Check the offsets at the start time |
| int[] offsets1 = new int[2]; |
| int[] offsets2 = new int[2]; |
| |
| getOffset(start, false, offsets1); |
| tz.getOffset(start, false, offsets2); |
| |
| if (ignoreDstAmount) { |
| if ((offsets1[0] + offsets1[1] != offsets2[0] + offsets2[1]) |
| || (offsets1[1] != 0 && offsets2[1] == 0) |
| || (offsets1[1] == 0 && offsets2[1] != 0)) { |
| return false; |
| } |
| } else { |
| if (offsets1[0] != offsets2[0] || offsets1[1] != offsets2[1]) { |
| return false; |
| } |
| } |
| |
| // Check transitions in the range |
| long time = start; |
| while (true) { |
| TimeZoneTransition tr1 = getNextTransition(time, false); |
| TimeZoneTransition tr2 = ((BasicTimeZone)tz).getNextTransition(time, false); |
| |
| if (ignoreDstAmount) { |
| // Skip a transition which only differ the amount of DST savings |
| if (tr1 != null |
| && (tr1.getFrom().getRawOffset() + tr1.getFrom().getDSTSavings() |
| == tr1.getTo().getRawOffset() + tr1.getTo().getDSTSavings()) |
| && (tr1.getFrom().getDSTSavings() != 0 && tr1.getTo().getDSTSavings() != 0)) { |
| tr1 = getNextTransition(tr1.getTime(), false); |
| } |
| if (tr2 != null |
| && (tr2.getFrom().getRawOffset() + tr2.getFrom().getDSTSavings() |
| == tr2.getTo().getRawOffset() + tr2.getTo().getDSTSavings()) |
| && (tr2.getFrom().getDSTSavings() != 0 && tr2.getTo().getDSTSavings() != 0)) { |
| tr2 = getNextTransition(tr2.getTime(), false); |
| } |
| } |
| |
| boolean inRange1 = false; |
| boolean inRange2 = false; |
| if (tr1 != null) { |
| if (tr1.getTime() <= end) { |
| inRange1 = true; |
| } |
| } |
| if (tr2 != null) { |
| if (tr2.getTime() <= end) { |
| inRange2 = true; |
| } |
| } |
| if (!inRange1 && !inRange2) { |
| // No more transition in the range |
| break; |
| } |
| if (!inRange1 || !inRange2) { |
| return false; |
| } |
| if (tr1.getTime() != tr2.getTime()) { |
| return false; |
| } |
| if (ignoreDstAmount) { |
| if (tr1.getTo().getRawOffset() + tr1.getTo().getDSTSavings() |
| != tr2.getTo().getRawOffset() + tr2.getTo().getDSTSavings() |
| || tr1.getTo().getDSTSavings() != 0 && tr2.getTo().getDSTSavings() == 0 |
| || tr1.getTo().getDSTSavings() == 0 && tr2.getTo().getDSTSavings() != 0) { |
| return false; |
| } |
| } else { |
| if (tr1.getTo().getRawOffset() != tr2.getTo().getRawOffset() || |
| tr1.getTo().getDSTSavings() != tr2.getTo().getDSTSavings()) { |
| return false; |
| } |
| } |
| time = tr1.getTime(); |
| } |
| return true; |
| } |
| |
| /** |
| * Gets the array of <code>TimeZoneRule</code> which represents the rule |
| * of this time zone object. The first element in the result array will |
| * be the <code>InitialTimeZoneRule</code> instance for the initial rule. |
| * The rest will be either <code>AnnualTimeZoneRule</code> or |
| * <code>TimeArrayTimeZoneRule</code> instances representing transitions. |
| * |
| * @return The array of <code>TimeZoneRule</code> which represents this |
| * time zone. |
| * |
| * @stable ICU 3.8 |
| */ |
| public abstract TimeZoneRule[] getTimeZoneRules(); |
| |
| /** |
| * Gets the array of <code>TimeZoneRule</code> which represents the rule |
| * of this time zone object since the specified start time. The first |
| * element in the result array will be the <code>InitialTimeZoneRule</code> |
| * instance for the initial rule. The rest will be either |
| * <code>AnnualTimeZoneRule</code> or <code>TimeArrayTimeZoneRule</code> |
| * instances representing transitions. |
| * |
| * @param start The start time (inclusive). |
| * @return The array of <code>TimeZoneRule</code> which represents this |
| * time zone since the start time. |
| * |
| * @stable ICU 3.8 |
| */ |
| public TimeZoneRule[] getTimeZoneRules(long start) { |
| TimeZoneRule[] all = getTimeZoneRules(); |
| TimeZoneTransition tzt = getPreviousTransition(start, true); |
| if (tzt == null) { |
| // No need to filter out rules only applicable to time before the start |
| return all; |
| } |
| |
| BitSet isProcessed = new BitSet(all.length); |
| List filteredRules = new LinkedList(); |
| |
| // Create initial rule |
| TimeZoneRule initial = new InitialTimeZoneRule(tzt.getTo().getName(), |
| tzt.getTo().getRawOffset(), tzt.getTo().getDSTSavings()); |
| filteredRules.add(initial); |
| isProcessed.set(0); |
| |
| // Mark rules which does not need to be processed |
| for (int i = 1; i < all.length; i++) { |
| Date d = all[i].getNextStart(start, initial.getRawOffset(), |
| initial.getDSTSavings(), false); |
| if (d == null) { |
| isProcessed.set(i); |
| } |
| } |
| |
| long time = start; |
| boolean bFinalStd = false, bFinalDst = false; |
| while(!bFinalStd || !bFinalDst) { |
| tzt = getNextTransition(time, false); |
| if (tzt == null) { |
| break; |
| } |
| time = tzt.getTime(); |
| |
| TimeZoneRule toRule = tzt.getTo(); |
| int ruleIdx = 1; |
| for (; ruleIdx < all.length; ruleIdx++) { |
| if (all[ruleIdx].equals(toRule)) { |
| break; |
| } |
| } |
| if (ruleIdx >= all.length) { |
| throw new IllegalStateException("The rule was not found"); |
| } |
| if (isProcessed.get(ruleIdx)) { |
| continue; |
| } |
| if (toRule instanceof TimeArrayTimeZoneRule) { |
| TimeArrayTimeZoneRule tar = (TimeArrayTimeZoneRule)toRule; |
| |
| // Get the previous raw offset and DST savings before the very first start time |
| long t = start; |
| while(true) { |
| tzt = getNextTransition(t, false); |
| if (tzt == null) { |
| break; |
| } |
| if (tzt.getTo().equals(tar)) { |
| break; |
| } |
| t = tzt.getTime(); |
| } |
| if (tzt != null) { |
| // Check if the entire start times to be added |
| Date firstStart = tar.getFirstStart(tzt.getFrom().getRawOffset(), |
| tzt.getFrom().getDSTSavings()); |
| if (firstStart.getTime() > start) { |
| // Just add the rule as is |
| filteredRules.add(tar); |
| } else { |
| // Collect transitions after the start time |
| long[] times = tar.getStartTimes(); |
| int timeType = tar.getTimeType(); |
| int idx; |
| for (idx = 0; idx < times.length; idx++) { |
| t = times[idx]; |
| if (timeType == DateTimeRule.STANDARD_TIME) { |
| t -= tzt.getFrom().getRawOffset(); |
| } |
| if (timeType == DateTimeRule.WALL_TIME) { |
| t -= tzt.getFrom().getDSTSavings(); |
| } |
| if (t > start) { |
| break; |
| } |
| } |
| int asize = times.length - idx; |
| if (asize > 0) { |
| long[] newtimes = new long[asize]; |
| System.arraycopy(times, idx, newtimes, 0, asize); |
| TimeArrayTimeZoneRule newtar = new TimeArrayTimeZoneRule( |
| tar.getName(), tar.getRawOffset(), tar.getDSTSavings(), |
| newtimes, tar.getTimeType()); |
| filteredRules.add(newtar); |
| } |
| } |
| } |
| } else if (toRule instanceof AnnualTimeZoneRule) { |
| AnnualTimeZoneRule ar = (AnnualTimeZoneRule)toRule; |
| Date firstStart = ar.getFirstStart(tzt.getFrom().getRawOffset(), |
| tzt.getFrom().getDSTSavings()); |
| if (firstStart.getTime() == tzt.getTime()) { |
| // Just add the rule as is |
| filteredRules.add(ar); |
| } else { |
| // Calculate the transition year |
| int[] dfields = new int[6]; |
| Grego.timeToFields(tzt.getTime(), dfields); |
| // Recreate the rule |
| AnnualTimeZoneRule newar = new AnnualTimeZoneRule(ar.getName(), |
| ar.getRawOffset(), ar.getDSTSavings(), |
| ar.getRule(), dfields[0], ar.getEndYear()); |
| filteredRules.add(newar); |
| } |
| // Check if this is a final rule |
| if (ar.getEndYear() == AnnualTimeZoneRule.MAX_YEAR) { |
| // After both final standard and dst rule are processed, |
| // exit this while loop. |
| if (ar.getDSTSavings() == 0) { |
| bFinalStd = true; |
| } else { |
| bFinalDst = true; |
| } |
| } |
| } |
| isProcessed.set(ruleIdx); |
| } |
| TimeZoneRule[] rules = new TimeZoneRule[filteredRules.size()]; |
| filteredRules.toArray(rules); |
| return rules; |
| } |
| |
| /** |
| * Gets the array of <code>TimeZoneRule</code> which represents the rule of |
| * this time zone object near the specified date. Some applications are not |
| * capable to handle historic time zone rule changes. Also some applications |
| * can only handle certain type of rule definitions. This method returns |
| * either a single <code>InitialTimeZoneRule</code> if this time zone does not |
| * have any daylight saving time within 1 year from the specified time, or a |
| * pair of <code>AnnualTimeZoneRule</code> whose rule type is |
| * <code>DateTimeRule.DOW</code> for date and <code>DateTimeRule.WALL_TIME</code> |
| * for time with a single <code>InitialTimeZoneRule</code> representing the |
| * initial time, when this time zone observes daylight saving time near the |
| * specified date. Thus, the result may be only valid for dates around the |
| * specified date. |
| * |
| * @param date The date to be used for <code>TimeZoneRule</code> extraction. |
| * @return The array of <code>TimeZoneRule</code>, either a single |
| * <code>InitialTimeZoneRule</code> object, or a pair of <code>AnnualTimeZoneRule</code> |
| * with a single <code>InitialTimeZoneRule</code>. The first element in the |
| * array is always a <code>InitialTimeZoneRule</code>. |
| * |
| * @stable ICU 3.8 |
| */ |
| public TimeZoneRule[] getSimpleTimeZoneRulesNear(long date) { |
| AnnualTimeZoneRule[] annualRules = null; |
| TimeZoneRule initialRule = null; |
| // Get the next transition |
| TimeZoneTransition tr = getNextTransition(date, false); |
| if (tr != null) { |
| String initialName = tr.getFrom().getName(); |
| int initialRaw = tr.getFrom().getRawOffset(); |
| int initialDst = tr.getFrom().getDSTSavings(); |
| |
| // Check if the next transition is either DST->STD or STD->DST and |
| // within roughly 1 year from the specified date |
| long nextTransitionTime = tr.getTime(); |
| if (((tr.getFrom().getDSTSavings() == 0 && tr.getTo().getDSTSavings() != 0) |
| || (tr.getFrom().getDSTSavings() != 0 && tr.getTo().getDSTSavings() == 0)) |
| && date + MILLIS_PER_YEAR > nextTransitionTime) { |
| // Get the next next transition |
| annualRules = new AnnualTimeZoneRule[2]; |
| // Get local wall time for the transition time |
| int dtfields[] = Grego.timeToFields(nextTransitionTime |
| + tr.getFrom().getRawOffset() + tr.getFrom().getDSTSavings(), null); |
| int weekInMonth = Grego.getDayOfWeekInMonth(dtfields[0], dtfields[1], dtfields[2]); |
| // Create DOW rule |
| DateTimeRule dtr = new DateTimeRule(dtfields[1], weekInMonth, dtfields[3], |
| dtfields[5], DateTimeRule.WALL_TIME); |
| annualRules[0] = new AnnualTimeZoneRule(tr.getTo().getName(), |
| tr.getTo().getRawOffset(), tr.getTo().getDSTSavings(), |
| dtr, dtfields[0], AnnualTimeZoneRule.MAX_YEAR); |
| |
| tr = getNextTransition(nextTransitionTime, false); |
| AnnualTimeZoneRule secondRule = null; |
| if (tr != null) { |
| // Check if the next next transition is either DST->STD or STD->DST |
| // and within roughly 1 year from the next transition |
| if (((tr.getFrom().getDSTSavings() == 0 && tr.getTo().getDSTSavings() != 0) |
| || (tr.getFrom().getDSTSavings() != 0 && tr.getTo().getDSTSavings() == 0)) |
| && nextTransitionTime + MILLIS_PER_YEAR > tr.getTime()) { |
| // Generate another DOW rule |
| dtfields = Grego.timeToFields(tr.getTime() |
| + tr.getFrom().getRawOffset() + tr.getFrom().getDSTSavings(), dtfields); |
| weekInMonth = Grego.getDayOfWeekInMonth(dtfields[0], dtfields[1], dtfields[2]); |
| dtr = new DateTimeRule(dtfields[1], weekInMonth, dtfields[3], dtfields[5], |
| DateTimeRule.WALL_TIME); |
| secondRule = new AnnualTimeZoneRule(tr.getTo().getName(), |
| tr.getTo().getRawOffset(), tr.getTo().getDSTSavings(), |
| dtr, dtfields[0] - 1, AnnualTimeZoneRule.MAX_YEAR); |
| // Make sure this rule can be applied to the specified date |
| Date d = secondRule.getPreviousStart(date, tr.getFrom().getRawOffset(), |
| tr.getFrom().getDSTSavings(), true); |
| if (d != null && d.getTime() <= date |
| && initialRaw == tr.getTo().getRawOffset() |
| && initialDst == tr.getTo().getDSTSavings()) { |
| // We can use this rule as the second transition rule |
| annualRules[1] = secondRule; |
| } |
| } |
| } |
| if (annualRules[1] == null) { |
| // Try previous transition |
| tr = getPreviousTransition(date, true); |
| if (tr != null) { |
| // Check if the previous transition is either DST->STD or STD->DST. |
| // The actual transition time does not matter here. |
| if ((tr.getFrom().getDSTSavings() == 0 && tr.getTo().getDSTSavings() != 0) |
| || (tr.getFrom().getDSTSavings() != 0 && tr.getTo().getDSTSavings() == 0)) { |
| // Generate another DOW rule |
| dtfields = Grego.timeToFields(tr.getTime() |
| + tr.getFrom().getRawOffset() + tr.getFrom().getDSTSavings(), dtfields); |
| weekInMonth = Grego.getDayOfWeekInMonth(dtfields[0], dtfields[1], dtfields[2]); |
| dtr = new DateTimeRule(dtfields[1], weekInMonth, dtfields[3], dtfields[5], |
| DateTimeRule.WALL_TIME); |
| secondRule = new AnnualTimeZoneRule(tr.getTo().getName(), |
| tr.getTo().getRawOffset(), tr.getTo().getDSTSavings(), |
| dtr, annualRules[0].getStartYear() - 1, AnnualTimeZoneRule.MAX_YEAR); |
| // Check if this rule start after the first rule after the specified date |
| Date d = secondRule.getNextStart(date, |
| tr.getFrom().getRawOffset(), tr.getFrom().getDSTSavings(), false); |
| if (d.getTime() > nextTransitionTime) { |
| // We can use this rule as the second transition rule |
| annualRules[1] = secondRule; |
| } |
| } |
| } |
| } |
| if (annualRules[1] == null) { |
| // Cannot generate a good pair of AnnualTimeZoneRule |
| annualRules = null; |
| } else { |
| // The initial rule should represent the rule before the previous transition |
| initialName = annualRules[0].getName(); |
| initialRaw = annualRules[0].getRawOffset(); |
| initialDst = annualRules[0].getDSTSavings(); |
| } |
| } |
| initialRule = new InitialTimeZoneRule(initialName, initialRaw, initialDst); |
| } else { |
| // Try the previous one |
| tr = getPreviousTransition(date, true); |
| if (tr != null) { |
| initialRule = new InitialTimeZoneRule(tr.getTo().getName(), |
| tr.getTo().getRawOffset(), tr.getTo().getDSTSavings()); |
| } else { |
| // No transitions in the past. Just use the current offsets |
| int[] offsets = new int[2]; |
| getOffset(date, false, offsets); |
| initialRule = new InitialTimeZoneRule(getID(), offsets[0], offsets[1]); |
| } |
| } |
| |
| TimeZoneRule[] result = null; |
| if (annualRules == null) { |
| result = new TimeZoneRule[1]; |
| result[0] = initialRule; |
| } else { |
| result = new TimeZoneRule[3]; |
| result[0] = initialRule; |
| result[1] = annualRules[0]; |
| result[2] = annualRules[1]; |
| } |
| |
| return result; |
| } |
| |
| /** |
| * The time type option for standard time used by |
| * {@link #getOffsetFromLocal(long, int, int, int[])} |
| * @internal |
| * @deprecated This API is ICU internal only. |
| */ |
| public static final int LOCAL_STD = 0x01; |
| |
| /** |
| * The time type option for daylight saving time used by |
| * {@link #getOffsetFromLocal(long, int, int, int[])} |
| * @internal |
| * @deprecated This API is ICU internal only. |
| */ |
| public static final int LOCAL_DST = 0x03; |
| |
| /** |
| * The option designate former time to be used by |
| * {@link #getOffsetFromLocal(long, int, int, int[])} |
| * @internal |
| * @deprecated This API is ICU internal only. |
| */ |
| public static final int LOCAL_FORMER = 0x04; |
| |
| /** |
| * The option designate latter time to be used by |
| * {@link #getOffsetFromLocal(long, int, int, int[])} |
| * @internal |
| * @deprecated This API is ICU internal only. |
| */ |
| public static final int LOCAL_LATTER = 0x0C; |
| |
| /** |
| * The bit mask for the time type option used by |
| * {@link #getOffsetFromLocal(long, int, int, int[])} |
| * @internal |
| * @deprecated This API is ICU internal only. |
| */ |
| protected static final int STD_DST_MASK = 0x03; |
| |
| /** |
| * The bit mask for the former/latter option used by |
| * {@link #getOffsetFromLocal(long, int, int, int[])} |
| * @internal |
| * @deprecated This API is ICU internal only. |
| */ |
| protected static final int FORMER_LATTER_MASK = 0x0C; |
| |
| /** |
| * Get time zone offsets from local wall time. |
| * @internal |
| * @deprecated This API is ICU internal only. |
| */ |
| public void getOffsetFromLocal(long date, |
| int nonExistingTimeOpt, int duplicatedTimeOpt, int[] offsets) { |
| throw new IllegalStateException("Not implemented"); |
| } |
| |
| /** |
| * Protected no arg constructor. |
| * @stable ICU 3.8 |
| */ |
| protected BasicTimeZone() { |
| } |
| } |
