[apple/icu.git] / icuSources / i18n / basictz.cpp

// © 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()) == *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
Commit	Line	Data
f3c0d7a5 A	1	// © 2016 and later: Unicode, Inc. and others.
f3c0d7a5 A	2	// License & terms of use: http://www.unicode.org/copyright.html
46f4442e A	3	/*
46f4442e A	4	*******************************************************************************
51004dcb	5	* Copyright (C) 2007-2013, International Business Machines Corporation and
729e4ab9	6	* others. All Rights Reserved.
46f4442e A	7	*******************************************************************************
	8	*/
	9
	10	#include "unicode/utypes.h"
	11
	12	#if !UCONFIG_NO_FORMATTING
	13
	14	#include "unicode/basictz.h"
	15	#include "gregoimp.h"
	16	#include "uvector.h"
	17	#include "cmemory.h"
	18
	19	U_NAMESPACE_BEGIN
	20
	21	#define MILLIS_PER_YEAR (3652460601000.0)
	22
	23	BasicTimeZone::BasicTimeZone()
	24	: TimeZone() {
	25	}
	26
	27	BasicTimeZone::BasicTimeZone(const UnicodeString &id)
	28	: TimeZone(id) {
	29	}
	30
	31	BasicTimeZone::BasicTimeZone(const BasicTimeZone& source)
	32	: TimeZone(source) {
	33	}
	34
	35	BasicTimeZone::~BasicTimeZone() {
	36	}
	37
	38	UBool
51004dcb A	39	BasicTimeZone::hasEquivalentTransitions(const BasicTimeZone& tz, UDate start, UDate end,
51004dcb A	40	UBool ignoreDstAmount, UErrorCode& status) const {
46f4442e A	41	if (U_FAILURE(status)) {
	42	return FALSE;
	43	}
	44	if (hasSameRules(tz)) {
	45	return TRUE;
	46	}
	47	// Check the offsets at the start time
	48	int32_t raw1, raw2, dst1, dst2;
	49	getOffset(start, FALSE, raw1, dst1, status);
	50	if (U_FAILURE(status)) {
	51	return FALSE;
	52	}
	53	tz.getOffset(start, FALSE, raw2, dst2, status);
	54	if (U_FAILURE(status)) {
	55	return FALSE;
	56	}
	57	if (ignoreDstAmount) {
	58	if ((raw1 + dst1 != raw2 + dst2)
	59	\|\| (dst1 != 0 && dst2 == 0)
	60	\|\| (dst1 == 0 && dst2 != 0)) {
	61	return FALSE;
	62	}
	63	} else {
	64	if (raw1 != raw2 \|\| dst1 != dst2) {
	65	return FALSE;
	66	}
	67	}
	68	// Check transitions in the range
	69	UDate time = start;
	70	TimeZoneTransition tr1, tr2;
	71	while (TRUE) {
	72	UBool avail1 = getNextTransition(time, FALSE, tr1);
	73	UBool avail2 = tz.getNextTransition(time, FALSE, tr2);
	74
	75	if (ignoreDstAmount) {
	76	// Skip a transition which only differ the amount of DST savings
729e4ab9 A	77	while (TRUE) {
	78	if (avail1
	79	&& tr1.getTime() <= end
	80	&& (tr1.getFrom()->getRawOffset() + tr1.getFrom()->getDSTSavings()
	81	== tr1.getTo()->getRawOffset() + tr1.getTo()->getDSTSavings())
	82	&& (tr1.getFrom()->getDSTSavings() != 0 && tr1.getTo()->getDSTSavings() != 0)) {
	83	getNextTransition(tr1.getTime(), FALSE, tr1);
	84	} else {
	85	break;
	86	}
46f4442e	87	}
729e4ab9 A	88	while (TRUE) {
	89	if (avail2
	90	&& tr2.getTime() <= end
	91	&& (tr2.getFrom()->getRawOffset() + tr2.getFrom()->getDSTSavings()
	92	== tr2.getTo()->getRawOffset() + tr2.getTo()->getDSTSavings())
	93	&& (tr2.getFrom()->getDSTSavings() != 0 && tr2.getTo()->getDSTSavings() != 0)) {
	94	tz.getNextTransition(tr2.getTime(), FALSE, tr2);
	95	} else {
	96	break;
	97	}
46f4442e A	98	}
	99	}
	100
	101	UBool inRange1 = (avail1 && tr1.getTime() <= end);
	102	UBool inRange2 = (avail2 && tr2.getTime() <= end);
	103	if (!inRange1 && !inRange2) {
	104	// No more transition in the range
	105	break;
	106	}
	107	if (!inRange1 \|\| !inRange2) {
	108	return FALSE;
	109	}
	110	if (tr1.getTime() != tr2.getTime()) {
	111	return FALSE;
	112	}
	113	if (ignoreDstAmount) {
	114	if (tr1.getTo()->getRawOffset() + tr1.getTo()->getDSTSavings()
	115	!= tr2.getTo()->getRawOffset() + tr2.getTo()->getDSTSavings()
729e4ab9 A	116	\|\| (tr1.getTo()->getDSTSavings() != 0 && tr2.getTo()->getDSTSavings() == 0)
729e4ab9 A	117	\|\| (tr1.getTo()->getDSTSavings() == 0 && tr2.getTo()->getDSTSavings() != 0)) {
46f4442e A	118	return FALSE;
	119	}
	120	} else {
	121	if (tr1.getTo()->getRawOffset() != tr2.getTo()->getRawOffset() \|\|
	122	tr1.getTo()->getDSTSavings() != tr2.getTo()->getDSTSavings()) {
	123	return FALSE;
	124	}
	125	}
	126	time = tr1.getTime();
	127	}
	128	return TRUE;
	129	}
	130
	131	void
	132	BasicTimeZone::getSimpleRulesNear(UDate date, InitialTimeZoneRule*& initial,
51004dcb	133	AnnualTimeZoneRule& std, AnnualTimeZoneRule& dst, UErrorCode& status) const {
46f4442e A	134	initial = NULL;
	135	std = NULL;
	136	dst = NULL;
	137	if (U_FAILURE(status)) {
	138	return;
	139	}
	140	int32_t initialRaw, initialDst;
	141	UnicodeString initialName;
	142
	143	AnnualTimeZoneRule *ar1 = NULL;
	144	AnnualTimeZoneRule *ar2 = NULL;
	145	UnicodeString name;
	146
	147	UBool avail;
	148	TimeZoneTransition tr;
	149	// Get the next transition
	150	avail = getNextTransition(date, FALSE, tr);
	151	if (avail) {
	152	tr.getFrom()->getName(initialName);
	153	initialRaw = tr.getFrom()->getRawOffset();
	154	initialDst = tr.getFrom()->getDSTSavings();
	155
	156	// Check if the next transition is either DST->STD or STD->DST and
	157	// within roughly 1 year from the specified date
	158	UDate nextTransitionTime = tr.getTime();
	159	if (((tr.getFrom()->getDSTSavings() == 0 && tr.getTo()->getDSTSavings() != 0)
	160	\|\| (tr.getFrom()->getDSTSavings() != 0 && tr.getTo()->getDSTSavings() == 0))
	161	&& (date + MILLIS_PER_YEAR > nextTransitionTime)) {
	162
	163	int32_t year, month, dom, dow, doy, mid;
	164	UDate d;
	165
	166	// Get local wall time for the next transition time
	167	Grego::timeToFields(nextTransitionTime + initialRaw + initialDst,
	168	year, month, dom, dow, doy, mid);
	169	int32_t weekInMonth = Grego::dayOfWeekInMonth(year, month, dom);
	170	// Create DOW rule
	171	DateTimeRule *dtr = new DateTimeRule(month, weekInMonth, dow, mid, DateTimeRule::WALL_TIME);
	172	tr.getTo()->getName(name);
729e4ab9 A	173
	174	// Note: SimpleTimeZone does not support raw offset change.
	175	// So we always use raw offset of the given time for the rule,
	176	// even raw offset is changed. This will result that the result
	177	// zone to return wrong offset after the transition.
	178	// When we encounter such case, we do not inspect next next
	179	// transition for another rule.
	180	ar1 = new AnnualTimeZoneRule(name, initialRaw, tr.getTo()->getDSTSavings(),
46f4442e A	181	dtr, year, AnnualTimeZoneRule::MAX_YEAR);
46f4442e A	182
729e4ab9 A	183	if (tr.getTo()->getRawOffset() == initialRaw) {
	184	// Get the next next transition
	185	avail = getNextTransition(nextTransitionTime, FALSE, tr);
	186	if (avail) {
	187	// Check if the next next transition is either DST->STD or STD->DST
	188	// and within roughly 1 year from the next transition
	189	if (((tr.getFrom()->getDSTSavings() == 0 && tr.getTo()->getDSTSavings() != 0)
	190	\|\| (tr.getFrom()->getDSTSavings() != 0 && tr.getTo()->getDSTSavings() == 0))
	191	&& nextTransitionTime + MILLIS_PER_YEAR > tr.getTime()) {
	192
	193	// Get local wall time for the next transition time
	194	Grego::timeToFields(tr.getTime() + tr.getFrom()->getRawOffset() + tr.getFrom()->getDSTSavings(),
	195	year, month, dom, dow, doy, mid);
	196	weekInMonth = Grego::dayOfWeekInMonth(year, month, dom);
	197	// Generate another DOW rule
	198	dtr = new DateTimeRule(month, weekInMonth, dow, mid, DateTimeRule::WALL_TIME);
	199	tr.getTo()->getName(name);
	200	ar2 = new AnnualTimeZoneRule(name, tr.getTo()->getRawOffset(), tr.getTo()->getDSTSavings(),
	201	dtr, year - 1, AnnualTimeZoneRule::MAX_YEAR);
	202
	203	// Make sure this rule can be applied to the specified date
	204	avail = ar2->getPreviousStart(date, tr.getFrom()->getRawOffset(), tr.getFrom()->getDSTSavings(), TRUE, d);
	205	if (!avail \|\| d > date
	206	\|\| initialRaw != tr.getTo()->getRawOffset()
	207	\|\| initialDst != tr.getTo()->getDSTSavings()) {
	208	// We cannot use this rule as the second transition rule
	209	delete ar2;
	210	ar2 = NULL;
	211	}
46f4442e A	212	}
	213	}
	214	}
	215	if (ar2 == NULL) {
	216	// Try previous transition
	217	avail = getPreviousTransition(date, TRUE, tr);
	218	if (avail) {
	219	// Check if the previous transition is either DST->STD or STD->DST.
	220	// The actual transition time does not matter here.
	221	if ((tr.getFrom()->getDSTSavings() == 0 && tr.getTo()->getDSTSavings() != 0)
	222	\|\| (tr.getFrom()->getDSTSavings() != 0 && tr.getTo()->getDSTSavings() == 0)) {
	223
	224	// Generate another DOW rule
	225	Grego::timeToFields(tr.getTime() + tr.getFrom()->getRawOffset() + tr.getFrom()->getDSTSavings(),
	226	year, month, dom, dow, doy, mid);
	227	weekInMonth = Grego::dayOfWeekInMonth(year, month, dom);
	228	dtr = new DateTimeRule(month, weekInMonth, dow, mid, DateTimeRule::WALL_TIME);
	229	tr.getTo()->getName(name);
729e4ab9 A	230
	231	// second rule raw/dst offsets should match raw/dst offsets
	232	// at the given time
	233	ar2 = new AnnualTimeZoneRule(name, initialRaw, initialDst,
46f4442e A	234	dtr, ar1->getStartYear() - 1, AnnualTimeZoneRule::MAX_YEAR);
	235
	236	// Check if this rule start after the first rule after the specified date
	237	avail = ar2->getNextStart(date, tr.getFrom()->getRawOffset(), tr.getFrom()->getDSTSavings(), FALSE, d);
	238	if (!avail \|\| d <= nextTransitionTime) {
	239	// We cannot use this rule as the second transition rule
	240	delete ar2;
	241	ar2 = NULL;
	242	}
	243	}
	244	}
	245	}
	246	if (ar2 == NULL) {
	247	// Cannot find a good pair of AnnualTimeZoneRule
	248	delete ar1;
	249	ar1 = NULL;
	250	} else {
	251	// The initial rule should represent the rule before the previous transition
	252	ar1->getName(initialName);
	253	initialRaw = ar1->getRawOffset();
	254	initialDst = ar1->getDSTSavings();
	255	}
	256	}
	257	}
	258	else {
	259	// Try the previous one
	260	avail = getPreviousTransition(date, TRUE, tr);
	261	if (avail) {
	262	tr.getTo()->getName(initialName);
	263	initialRaw = tr.getTo()->getRawOffset();
	264	initialDst = tr.getTo()->getDSTSavings();
	265	} else {
	266	// No transitions in the past. Just use the current offsets
	267	getOffset(date, FALSE, initialRaw, initialDst, status);
	268	if (U_FAILURE(status)) {
	269	return;
	270	}
	271	}
	272	}
	273	// Set the initial rule
	274	initial = new InitialTimeZoneRule(initialName, initialRaw, initialDst);
	275
	276	// Set the standard and daylight saving rules
	277	if (ar1 != NULL && ar2 != NULL) {
	278	if (ar1->getDSTSavings() != 0) {
	279	dst = ar1;
	280	std = ar2;
	281	} else {
	282	std = ar1;
	283	dst = ar2;
	284	}
	285	}
	286	}
	287
	288	void
	289	BasicTimeZone::getTimeZoneRulesAfter(UDate start, InitialTimeZoneRule*& initial,
51004dcb	290	UVector*& transitionRules, UErrorCode& status) const {
46f4442e A	291	if (U_FAILURE(status)) {
	292	return;
	293	}
	294
	295	const InitialTimeZoneRule *orgini;
	296	const TimeZoneRule **orgtrs = NULL;
	297	TimeZoneTransition tzt;
	298	UBool avail;
	299	UVector *orgRules = NULL;
	300	int32_t ruleCount;
	301	TimeZoneRule *r = NULL;
	302	UBool *done = NULL;
	303	InitialTimeZoneRule *res_initial = NULL;
	304	UVector *filteredRules = NULL;
	305	UnicodeString name;
	306	int32_t i;
	307	UDate time, t;
	308	UDate *newTimes = NULL;
	309	UDate firstStart;
	310	UBool bFinalStd = FALSE, bFinalDst = FALSE;
	311
	312	// Original transition rules
	313	ruleCount = countTransitionRules(status);
	314	if (U_FAILURE(status)) {
	315	return;
	316	}
	317	orgRules = new UVector(ruleCount, status);
	318	if (U_FAILURE(status)) {
	319	return;
	320	}
	321	orgtrs = (const TimeZoneRule*)uprv_malloc(sizeof(TimeZoneRule)*ruleCount);
	322	if (orgtrs == NULL) {
	323	status = U_MEMORY_ALLOCATION_ERROR;
	324	goto error;
	325	}
	326	getTimeZoneRules(orgini, orgtrs, ruleCount, status);
	327	if (U_FAILURE(status)) {
	328	goto error;
	329	}
	330	for (i = 0; i < ruleCount; i++) {
	331	orgRules->addElement(orgtrs[i]->clone(), status);
	332	if (U_FAILURE(status)) {
	333	goto error;
	334	}
	335	}
	336	uprv_free(orgtrs);
	337	orgtrs = NULL;
	338
	339	avail = getPreviousTransition(start, TRUE, tzt);
	340	if (!avail) {
	341	// No need to filter out rules only applicable to time before the start
	342	initial = orgini->clone();
	343	transitionRules = orgRules;
	344	return;
	345	}
	346
	347	done = (UBool)uprv_malloc(sizeof(UBool)ruleCount);
	348	if (done == NULL) {
	349	status = U_MEMORY_ALLOCATION_ERROR;
	350	goto error;
	351	}
	352	filteredRules = new UVector(status);
	353	if (U_FAILURE(status)) {
	354	goto error;
355	}
356
357	// Create initial rule
358	tzt.getTo()->getName(name);
359	res_initial = new InitialTimeZoneRule(name, tzt.getTo()->getRawOffset(),
360	tzt.getTo()->getDSTSavings());
361
362	// Mark rules which does not need to be processed
363	for (i = 0; i < ruleCount; i++) {
364	r = (TimeZoneRule*)orgRules->elementAt(i);
365	avail = r->getNextStart(start, res_initial->getRawOffset(), res_initial->getDSTSavings(), FALSE, time);
366	done[i] = !avail;
367	}
368
369	time = start;
370	while (!bFinalStd \|\| !bFinalDst) {
371	avail = getNextTransition(time, FALSE, tzt);
372	if (!avail) {
373	break;
374	}
729e4ab9 A	375	UDate updatedTime = tzt.getTime();
	376	if (updatedTime == time) {
	377	// Can get here if rules for start & end of daylight time have exactly
	378	// the same time.
	379	// TODO: fix getNextTransition() to prevent it?
	380	status = U_INVALID_STATE_ERROR;
	381	goto error;
	382	}
	383	time = updatedTime;
46f4442e A	384
	385	const TimeZoneRule *toRule = tzt.getTo();
	386	for (i = 0; i < ruleCount; i++) {
	387	r = (TimeZoneRule*)orgRules->elementAt(i);
	388	if (r == toRule) {
	389	break;
	390	}
	391	}
	392	if (i >= ruleCount) {
	393	// This case should never happen
	394	status = U_INVALID_STATE_ERROR;
	395	goto error;
	396	}
	397	if (done[i]) {
	398	continue;
	399	}
729e4ab9 A	400	const TimeArrayTimeZoneRule tar = dynamic_cast<const TimeArrayTimeZoneRule >(toRule);
	401	const AnnualTimeZoneRule *ar;
	402	if (tar != NULL) {
46f4442e A	403	// Get the previous raw offset and DST savings before the very first start time
	404	TimeZoneTransition tzt0;
	405	t = start;
	406	while (TRUE) {
	407	avail = getNextTransition(t, FALSE, tzt0);
	408	if (!avail) {
	409	break;
	410	}
	411	if ((tzt0.getTo()) == tar) {
	412	break;
	413	}
	414	t = tzt0.getTime();
	415	}
	416	if (avail) {
	417	// Check if the entire start times to be added
	418	tar->getFirstStart(tzt.getFrom()->getRawOffset(), tzt.getFrom()->getDSTSavings(), firstStart);
	419	if (firstStart > start) {
	420	// Just add the rule as is
	421	filteredRules->addElement(tar->clone(), status);
	422	if (U_FAILURE(status)) {
	423	goto error;
	424	}
	425	} else {
	426	// Colllect transitions after the start time
	427	int32_t startTimes;
	428	DateTimeRule::TimeRuleType timeType;
	429	int32_t idx;
	430
	431	startTimes = tar->countStartTimes();
	432	timeType = tar->getTimeType();
	433	for (idx = 0; idx < startTimes; idx++) {
	434	tar->getStartTimeAt(idx, t);
	435	if (timeType == DateTimeRule::STANDARD_TIME) {
	436	t -= tzt.getFrom()->getRawOffset();
	437	}
	438	if (timeType == DateTimeRule::WALL_TIME) {
	439	t -= tzt.getFrom()->getDSTSavings();
	440	}
	441	if (t > start) {
	442	break;
	443	}
	444	}
	445	int32_t asize = startTimes - idx;
	446	if (asize > 0) {
	447	newTimes = (UDate)uprv_malloc(sizeof(UDate) asize);
	448	if (newTimes == NULL) {
	449	status = U_MEMORY_ALLOCATION_ERROR;
	450	goto error;
	451	}
	452	for (int32_t newidx = 0; newidx < asize; newidx++) {
	453	tar->getStartTimeAt(idx + newidx, newTimes[newidx]);
	454	if (U_FAILURE(status)) {
	455	uprv_free(newTimes);
	456	newTimes = NULL;
	457	goto error;
	458	}
	459	}
	460	tar->getName(name);
	461	TimeArrayTimeZoneRule *newTar = new TimeArrayTimeZoneRule(name,
	462	tar->getRawOffset(), tar->getDSTSavings(), newTimes, asize, timeType);
	463	uprv_free(newTimes);
	464	filteredRules->addElement(newTar, status);
	465	if (U_FAILURE(status)) {
	466	goto error;
467	}
468	}
469	}
470	}
729e4ab9	471	} else if ((ar = dynamic_cast<const AnnualTimeZoneRule *>(toRule)) != NULL) {
46f4442e A	472	ar->getFirstStart(tzt.getFrom()->getRawOffset(), tzt.getFrom()->getDSTSavings(), firstStart);
	473	if (firstStart == tzt.getTime()) {
	474	// Just add the rule as is
	475	filteredRules->addElement(ar->clone(), status);
	476	if (U_FAILURE(status)) {
	477	goto error;
	478	}
	479	} else {
	480	// Calculate the transition year
	481	int32_t year, month, dom, dow, doy, mid;
	482	Grego::timeToFields(tzt.getTime(), year, month, dom, dow, doy, mid);
	483	// Re-create the rule
	484	ar->getName(name);
	485	AnnualTimeZoneRule *newAr = new AnnualTimeZoneRule(name, ar->getRawOffset(), ar->getDSTSavings(),
	486	*(ar->getRule()), year, ar->getEndYear());
	487	filteredRules->addElement(newAr, status);
	488	if (U_FAILURE(status)) {
	489	goto error;
	490	}
	491	}
	492	// check if this is a final rule
	493	if (ar->getEndYear() == AnnualTimeZoneRule::MAX_YEAR) {
	494	// After bot final standard and dst rules are processed,
	495	// exit this while loop.
	496	if (ar->getDSTSavings() == 0) {
	497	bFinalStd = TRUE;
	498	} else {
	499	bFinalDst = TRUE;
	500	}
	501	}
	502	}
	503	done[i] = TRUE;
	504	}
	505
	506	// Set the results
	507	if (orgRules != NULL) {
	508	while (!orgRules->isEmpty()) {
	509	r = (TimeZoneRule*)orgRules->orphanElementAt(0);
	510	delete r;
	511	}
	512	delete orgRules;
	513	}
	514	if (done != NULL) {
	515	uprv_free(done);
	516	}
	517
	518	initial = res_initial;
	519	transitionRules = filteredRules;
	520	return;
	521
	522	error:
	523	if (orgtrs != NULL) {
	524	uprv_free(orgtrs);
	525	}
	526	if (orgRules != NULL) {
	527	while (!orgRules->isEmpty()) {
	528	r = (TimeZoneRule*)orgRules->orphanElementAt(0);
	529	delete r;
	530	}
	531	delete orgRules;
	532	}
	533	if (done != NULL) {
729e4ab9 A	534	if (filteredRules != NULL) {
	535	while (!filteredRules->isEmpty()) {
	536	r = (TimeZoneRule*)filteredRules->orphanElementAt(0);
	537	delete r;
	538	}
	539	delete filteredRules;
	540	}
	541	delete res_initial;
46f4442e A	542	uprv_free(done);
	543	}
	544
	545	initial = NULL;
	546	transitionRules = NULL;
	547	}
	548
	549	void
729e4ab9	550	BasicTimeZone::getOffsetFromLocal(UDate /date/, int32_t /nonExistingTimeOpt/, int32_t /duplicatedTimeOpt/,
51004dcb	551	int32_t& /rawOffset/, int32_t& /dstOffset/, UErrorCode& status) const {
46f4442e A	552	if (U_FAILURE(status)) {
	553	return;
	554	}
	555	status = U_UNSUPPORTED_ERROR;
	556	}
	557
	558	U_NAMESPACE_END
	559
	560	#endif /* #if !UCONFIG_NO_FORMATTING */
	561
	562	//eof