diff options
Diffstat (limited to 'libicui18n/libicui18n/basictz.cpp')
| -rw-r--r-- | libicui18n/libicui18n/basictz.cpp | 562 |
1 files changed, 562 insertions, 0 deletions
diff --git a/libicui18n/libicui18n/basictz.cpp b/libicui18n/libicui18n/basictz.cpp new file mode 100644 index 0000000..430cb56 --- /dev/null +++ b/libicui18n/libicui18n/basictz.cpp @@ -0,0 +1,562 @@ +// © 2016 and later: Unicode, Inc. and others. +// License & terms of use: http://www.unicode.org/copyright.html +/* +******************************************************************************* +* Copyright (C) 2007-2013, International Business Machines Corporation and +* others. All Rights Reserved. +******************************************************************************* +*/ + +#include "unicode/utypes.h" + +#if !UCONFIG_NO_FORMATTING + +#include "unicode/basictz.h" +#include "gregoimp.h" +#include "uvector.h" +#include "cmemory.h" + +U_NAMESPACE_BEGIN + +#define MILLIS_PER_YEAR (365*24*60*60*1000.0) + +BasicTimeZone::BasicTimeZone() +: TimeZone() { +} + +BasicTimeZone::BasicTimeZone(const UnicodeString &id) +: TimeZone(id) { +} + +BasicTimeZone::BasicTimeZone(const BasicTimeZone& source) +: TimeZone(source) { +} + +BasicTimeZone::~BasicTimeZone() { +} + +UBool +BasicTimeZone::hasEquivalentTransitions(const BasicTimeZone& tz, UDate start, UDate end, + UBool ignoreDstAmount, UErrorCode& status) const { + if (U_FAILURE(status)) { + return FALSE; + } + if (hasSameRules(tz)) { + return TRUE; + } + // Check the offsets at the start time + int32_t raw1, raw2, dst1, dst2; + getOffset(start, FALSE, raw1, dst1, status); + if (U_FAILURE(status)) { + return FALSE; + } + tz.getOffset(start, FALSE, raw2, dst2, status); + if (U_FAILURE(status)) { + return FALSE; + } + if (ignoreDstAmount) { + if ((raw1 + dst1 != raw2 + dst2) + || (dst1 != 0 && dst2 == 0) + || (dst1 == 0 && dst2 != 0)) { + return FALSE; + } + } else { + if (raw1 != raw2 || dst1 != dst2) { + return FALSE; + } + } + // Check transitions in the range + UDate time = start; + TimeZoneTransition tr1, tr2; + while (TRUE) { + UBool avail1 = getNextTransition(time, FALSE, tr1); + UBool avail2 = tz.getNextTransition(time, FALSE, tr2); + + if (ignoreDstAmount) { + // Skip a transition which only differ the amount of DST savings + while (TRUE) { + if (avail1 + && tr1.getTime() <= end + && (tr1.getFrom()->getRawOffset() + tr1.getFrom()->getDSTSavings() + == tr1.getTo()->getRawOffset() + tr1.getTo()->getDSTSavings()) + && (tr1.getFrom()->getDSTSavings() != 0 && tr1.getTo()->getDSTSavings() != 0)) { + getNextTransition(tr1.getTime(), FALSE, tr1); + } else { + break; + } + } + while (TRUE) { + if (avail2 + && tr2.getTime() <= end + && (tr2.getFrom()->getRawOffset() + tr2.getFrom()->getDSTSavings() + == tr2.getTo()->getRawOffset() + tr2.getTo()->getDSTSavings()) + && (tr2.getFrom()->getDSTSavings() != 0 && tr2.getTo()->getDSTSavings() != 0)) { + tz.getNextTransition(tr2.getTime(), FALSE, tr2); + } else { + break; + } + } + } + + UBool inRange1 = (avail1 && tr1.getTime() <= end); + UBool inRange2 = (avail2 && tr2.getTime() <= end); + 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; +} + +void +BasicTimeZone::getSimpleRulesNear(UDate date, InitialTimeZoneRule*& initial, + AnnualTimeZoneRule*& std, AnnualTimeZoneRule*& dst, UErrorCode& status) const { + initial = NULL; + std = NULL; + dst = NULL; + if (U_FAILURE(status)) { + return; + } + int32_t initialRaw, initialDst; + UnicodeString initialName; + + AnnualTimeZoneRule *ar1 = NULL; + AnnualTimeZoneRule *ar2 = NULL; + UnicodeString name; + + UBool avail; + TimeZoneTransition tr; + // Get the next transition + avail = getNextTransition(date, FALSE, tr); + if (avail) { + tr.getFrom()->getName(initialName); + initialRaw = tr.getFrom()->getRawOffset(); + 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 + UDate 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)) { + + int32_t year, month, dom, dow, doy, mid; + UDate d; + + // Get local wall time for the next transition time + Grego::timeToFields(nextTransitionTime + initialRaw + initialDst, + year, month, dom, dow, doy, mid); + int32_t weekInMonth = Grego::dayOfWeekInMonth(year, month, dom); + // Create DOW rule + DateTimeRule *dtr = new DateTimeRule(month, weekInMonth, dow, mid, DateTimeRule::WALL_TIME); + tr.getTo()->getName(name); + + // Note: SimpleTimeZone does not support raw offset change. + // So we always use raw offset of the given time for the rule, + // even raw offset is changed. This will result that the result + // zone to return wrong offset after the transition. + // When we encounter such case, we do not inspect next next + // transition for another rule. + ar1 = new AnnualTimeZoneRule(name, initialRaw, tr.getTo()->getDSTSavings(), + dtr, year, AnnualTimeZoneRule::MAX_YEAR); + + if (tr.getTo()->getRawOffset() == initialRaw) { + // Get the next next transition + avail = getNextTransition(nextTransitionTime, FALSE, tr); + if (avail) { + // 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()) { + + // Get local wall time for the next transition time + Grego::timeToFields(tr.getTime() + tr.getFrom()->getRawOffset() + tr.getFrom()->getDSTSavings(), + year, month, dom, dow, doy, mid); + weekInMonth = Grego::dayOfWeekInMonth(year, month, dom); + // Generate another DOW rule + dtr = new DateTimeRule(month, weekInMonth, dow, mid, DateTimeRule::WALL_TIME); + tr.getTo()->getName(name); + ar2 = new AnnualTimeZoneRule(name, tr.getTo()->getRawOffset(), tr.getTo()->getDSTSavings(), + dtr, year - 1, AnnualTimeZoneRule::MAX_YEAR); + + // Make sure this rule can be applied to the specified date + avail = ar2->getPreviousStart(date, tr.getFrom()->getRawOffset(), tr.getFrom()->getDSTSavings(), TRUE, d); + if (!avail || d > date + || initialRaw != tr.getTo()->getRawOffset() + || initialDst != tr.getTo()->getDSTSavings()) { + // We cannot use this rule as the second transition rule + delete ar2; + ar2 = NULL; + } + } + } + } + if (ar2 == NULL) { + // Try previous transition + avail = getPreviousTransition(date, TRUE, tr); + if (avail) { + // 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 + Grego::timeToFields(tr.getTime() + tr.getFrom()->getRawOffset() + tr.getFrom()->getDSTSavings(), + year, month, dom, dow, doy, mid); + weekInMonth = Grego::dayOfWeekInMonth(year, month, dom); + dtr = new DateTimeRule(month, weekInMonth, dow, mid, DateTimeRule::WALL_TIME); + tr.getTo()->getName(name); + + // second rule raw/dst offsets should match raw/dst offsets + // at the given time + ar2 = new AnnualTimeZoneRule(name, initialRaw, initialDst, + dtr, ar1->getStartYear() - 1, AnnualTimeZoneRule::MAX_YEAR); + + // Check if this rule start after the first rule after the specified date + avail = ar2->getNextStart(date, tr.getFrom()->getRawOffset(), tr.getFrom()->getDSTSavings(), FALSE, d); + if (!avail || d <= nextTransitionTime) { + // We cannot use this rule as the second transition rule + delete ar2; + ar2 = NULL; + } + } + } + } + if (ar2 == NULL) { + // Cannot find a good pair of AnnualTimeZoneRule + delete ar1; + ar1 = NULL; + } else { + // The initial rule should represent the rule before the previous transition + ar1->getName(initialName); + initialRaw = ar1->getRawOffset(); + initialDst = ar1->getDSTSavings(); + } + } + } + else { + // Try the previous one + avail = getPreviousTransition(date, TRUE, tr); + if (avail) { + tr.getTo()->getName(initialName); + initialRaw = tr.getTo()->getRawOffset(); + initialDst = tr.getTo()->getDSTSavings(); + } else { + // No transitions in the past. Just use the current offsets + getOffset(date, FALSE, initialRaw, initialDst, status); + if (U_FAILURE(status)) { + return; + } + } + } + // Set the initial rule + initial = new InitialTimeZoneRule(initialName, initialRaw, initialDst); + + // Set the standard and daylight saving rules + if (ar1 != NULL && ar2 != NULL) { + if (ar1->getDSTSavings() != 0) { + dst = ar1; + std = ar2; + } else { + std = ar1; + dst = ar2; + } + } +} + +void +BasicTimeZone::getTimeZoneRulesAfter(UDate start, InitialTimeZoneRule*& initial, + UVector*& transitionRules, UErrorCode& status) const { + if (U_FAILURE(status)) { + return; + } + + const InitialTimeZoneRule *orgini; + const TimeZoneRule **orgtrs = NULL; + TimeZoneTransition tzt; + UBool avail; + UVector *orgRules = NULL; + int32_t ruleCount; + TimeZoneRule *r = NULL; + UBool *done = NULL; + InitialTimeZoneRule *res_initial = NULL; + UVector *filteredRules = NULL; + UnicodeString name; + int32_t i; + UDate time, t; + UDate *newTimes = NULL; + UDate firstStart; + UBool bFinalStd = FALSE, bFinalDst = FALSE; + + // Original transition rules + ruleCount = countTransitionRules(status); + if (U_FAILURE(status)) { + return; + } + orgRules = new UVector(ruleCount, status); + if (U_FAILURE(status)) { + return; + } + orgtrs = (const TimeZoneRule**)uprv_malloc(sizeof(TimeZoneRule*)*ruleCount); + if (orgtrs == NULL) { + status = U_MEMORY_ALLOCATION_ERROR; + goto error; + } + getTimeZoneRules(orgini, orgtrs, ruleCount, status); + if (U_FAILURE(status)) { + goto error; + } + for (i = 0; i < ruleCount; i++) { + orgRules->addElement(orgtrs[i]->clone(), status); + if (U_FAILURE(status)) { + goto error; + } + } + uprv_free(orgtrs); + orgtrs = NULL; + + avail = getPreviousTransition(start, TRUE, tzt); + if (!avail) { + // No need to filter out rules only applicable to time before the start + initial = orgini->clone(); + transitionRules = orgRules; + return; + } + + done = (UBool*)uprv_malloc(sizeof(UBool)*ruleCount); + if (done == NULL) { + status = U_MEMORY_ALLOCATION_ERROR; + goto error; + } + filteredRules = new UVector(status); + if (U_FAILURE(status)) { + goto error; + } + + // Create initial rule + tzt.getTo()->getName(name); + res_initial = new InitialTimeZoneRule(name, tzt.getTo()->getRawOffset(), + tzt.getTo()->getDSTSavings()); + + // Mark rules which does not need to be processed + for (i = 0; i < ruleCount; i++) { + r = (TimeZoneRule*)orgRules->elementAt(i); + avail = r->getNextStart(start, res_initial->getRawOffset(), res_initial->getDSTSavings(), FALSE, time); + done[i] = !avail; + } + + time = start; + while (!bFinalStd || !bFinalDst) { + avail = getNextTransition(time, FALSE, tzt); + if (!avail) { + break; + } + UDate updatedTime = tzt.getTime(); + if (updatedTime == time) { + // Can get here if rules for start & end of daylight time have exactly + // the same time. + // TODO: fix getNextTransition() to prevent it? + status = U_INVALID_STATE_ERROR; + goto error; + } + time = updatedTime; + + const TimeZoneRule *toRule = tzt.getTo(); + for (i = 0; i < ruleCount; i++) { + r = (TimeZoneRule*)orgRules->elementAt(i); + if (*r == *toRule) { + break; + } + } + if (i >= ruleCount) { + // This case should never happen + status = U_INVALID_STATE_ERROR; + goto error; + } + if (done[i]) { + continue; + } + const TimeArrayTimeZoneRule *tar = dynamic_cast<const TimeArrayTimeZoneRule *>(toRule); + const AnnualTimeZoneRule *ar; + if (tar != NULL) { + // Get the previous raw offset and DST savings before the very first start time + TimeZoneTransition tzt0; + t = start; + while (TRUE) { + avail = getNextTransition(t, FALSE, tzt0); + if (!avail) { + break; + } + if (tzt0.getTo()->operator==(*tar)) { + break; + } + t = tzt0.getTime(); + } + if (avail) { + // Check if the entire start times to be added + tar->getFirstStart(tzt.getFrom()->getRawOffset(), tzt.getFrom()->getDSTSavings(), firstStart); + if (firstStart > start) { + // Just add the rule as is + filteredRules->addElement(tar->clone(), status); + if (U_FAILURE(status)) { + goto error; + } + } else { + // Colllect transitions after the start time + int32_t startTimes; + DateTimeRule::TimeRuleType timeType; + int32_t idx; + + startTimes = tar->countStartTimes(); + timeType = tar->getTimeType(); + for (idx = 0; idx < startTimes; idx++) { + tar->getStartTimeAt(idx, t); + if (timeType == DateTimeRule::STANDARD_TIME) { + t -= tzt.getFrom()->getRawOffset(); + } + if (timeType == DateTimeRule::WALL_TIME) { + t -= tzt.getFrom()->getDSTSavings(); + } + if (t > start) { + break; + } + } + int32_t asize = startTimes - idx; + if (asize > 0) { + newTimes = (UDate*)uprv_malloc(sizeof(UDate) * asize); + if (newTimes == NULL) { + status = U_MEMORY_ALLOCATION_ERROR; + goto error; + } + for (int32_t newidx = 0; newidx < asize; newidx++) { + tar->getStartTimeAt(idx + newidx, newTimes[newidx]); + if (U_FAILURE(status)) { + uprv_free(newTimes); + newTimes = NULL; + goto error; + } + } + tar->getName(name); + TimeArrayTimeZoneRule *newTar = new TimeArrayTimeZoneRule(name, + tar->getRawOffset(), tar->getDSTSavings(), newTimes, asize, timeType); + uprv_free(newTimes); + filteredRules->addElement(newTar, status); + if (U_FAILURE(status)) { + goto error; + } + } + } + } + } else if ((ar = dynamic_cast<const AnnualTimeZoneRule *>(toRule)) != NULL) { + ar->getFirstStart(tzt.getFrom()->getRawOffset(), tzt.getFrom()->getDSTSavings(), firstStart); + if (firstStart == tzt.getTime()) { + // Just add the rule as is + filteredRules->addElement(ar->clone(), status); + if (U_FAILURE(status)) { + goto error; + } + } else { + // Calculate the transition year + int32_t year, month, dom, dow, doy, mid; + Grego::timeToFields(tzt.getTime(), year, month, dom, dow, doy, mid); + // Re-create the rule + ar->getName(name); + AnnualTimeZoneRule *newAr = new AnnualTimeZoneRule(name, ar->getRawOffset(), ar->getDSTSavings(), + *(ar->getRule()), year, ar->getEndYear()); + filteredRules->addElement(newAr, status); + if (U_FAILURE(status)) { + goto error; + } + } + // check if this is a final rule + if (ar->getEndYear() == AnnualTimeZoneRule::MAX_YEAR) { + // After bot final standard and dst rules are processed, + // exit this while loop. + if (ar->getDSTSavings() == 0) { + bFinalStd = TRUE; + } else { + bFinalDst = TRUE; + } + } + } + done[i] = TRUE; + } + + // Set the results + if (orgRules != NULL) { + while (!orgRules->isEmpty()) { + r = (TimeZoneRule*)orgRules->orphanElementAt(0); + delete r; + } + delete orgRules; + } + if (done != NULL) { + uprv_free(done); + } + + initial = res_initial; + transitionRules = filteredRules; + return; + +error: + if (orgtrs != NULL) { + uprv_free(orgtrs); + } + if (orgRules != NULL) { + while (!orgRules->isEmpty()) { + r = (TimeZoneRule*)orgRules->orphanElementAt(0); + delete r; + } + delete orgRules; + } + if (done != NULL) { + if (filteredRules != NULL) { + while (!filteredRules->isEmpty()) { + r = (TimeZoneRule*)filteredRules->orphanElementAt(0); + delete r; + } + delete filteredRules; + } + delete res_initial; + uprv_free(done); + } + + initial = NULL; + transitionRules = NULL; +} + +void +BasicTimeZone::getOffsetFromLocal(UDate /*date*/, int32_t /*nonExistingTimeOpt*/, int32_t /*duplicatedTimeOpt*/, + int32_t& /*rawOffset*/, int32_t& /*dstOffset*/, UErrorCode& status) const { + if (U_FAILURE(status)) { + return; + } + status = U_UNSUPPORTED_ERROR; +} + +U_NAMESPACE_END + +#endif /* #if !UCONFIG_NO_FORMATTING */ + +//eof |