The Tor Browser / file comparison

comparison: intl/icu/source/i18n/rbtz.cpp

intl/icu/source/i18n/rbtz.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:762a4c021ea6
1 /*
2 *******************************************************************************
3 * Copyright (C) 2007-2013, International Business Machines Corporation and
4 * others. All Rights Reserved.
5 *******************************************************************************
6 */
7
8 #include "utypeinfo.h" // for 'typeid' to work
9
10 #include "unicode/utypes.h"
11
12 #if !UCONFIG_NO_FORMATTING
13
14 #include "unicode/rbtz.h"
15 #include "unicode/gregocal.h"
16 #include "uvector.h"
17 #include "gregoimp.h"
18 #include "cmemory.h"
19 #include "umutex.h"
20
21 U_NAMESPACE_BEGIN
22
23 /**
24 * A struct representing a time zone transition
25 */
26 struct Transition {
27 UDate time;
28 TimeZoneRule* from;
29 TimeZoneRule* to;
30 };
31
32 static UBool compareRules(UVector* rules1, UVector* rules2) {
33 if (rules1 == NULL && rules2 == NULL) {
34 return TRUE;
35 } else if (rules1 == NULL || rules2 == NULL) {
36 return FALSE;
37 }
38 int32_t size = rules1->size();
39 if (size != rules2->size()) {
40 return FALSE;
41 }
42 for (int32_t i = 0; i < size; i++) {
43 TimeZoneRule *r1 = (TimeZoneRule*)rules1->elementAt(i);
44 TimeZoneRule *r2 = (TimeZoneRule*)rules2->elementAt(i);
45 if (*r1 != *r2) {
46 return FALSE;
47 }
48 }
49 return TRUE;
50 }
51
52 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(RuleBasedTimeZone)
53
54 RuleBasedTimeZone::RuleBasedTimeZone(const UnicodeString& id, InitialTimeZoneRule* initialRule)
55 : BasicTimeZone(id), fInitialRule(initialRule), fHistoricRules(NULL), fFinalRules(NULL),
56 fHistoricTransitions(NULL), fUpToDate(FALSE) {
57 }
58
59 RuleBasedTimeZone::RuleBasedTimeZone(const RuleBasedTimeZone& source)
60 : BasicTimeZone(source), fInitialRule(source.fInitialRule->clone()),
61 fHistoricTransitions(NULL), fUpToDate(FALSE) {
62 fHistoricRules = copyRules(source.fHistoricRules);
63 fFinalRules = copyRules(source.fFinalRules);
64 if (source.fUpToDate) {
65 UErrorCode status = U_ZERO_ERROR;
66 complete(status);
67 }
68 }
69
70 RuleBasedTimeZone::~RuleBasedTimeZone() {
71 deleteTransitions();
72 deleteRules();
73 }
74
75 RuleBasedTimeZone&
76 RuleBasedTimeZone::operator=(const RuleBasedTimeZone& right) {
77 if (*this != right) {
78 BasicTimeZone::operator=(right);
79 deleteRules();
80 fInitialRule = right.fInitialRule->clone();
81 fHistoricRules = copyRules(right.fHistoricRules);
82 fFinalRules = copyRules(right.fFinalRules);
83 deleteTransitions();
84 fUpToDate = FALSE;
85 }
86 return *this;
87 }
88
89 UBool
90 RuleBasedTimeZone::operator==(const TimeZone& that) const {
91 if (this == &that) {
92 return TRUE;
93 }
94 if (typeid(*this) != typeid(that)
95 || BasicTimeZone::operator==(that) == FALSE) {
96 return FALSE;
97 }
98 RuleBasedTimeZone *rbtz = (RuleBasedTimeZone*)&that;
99 if (*fInitialRule != *(rbtz->fInitialRule)) {
100 return FALSE;
101 }
102 if (compareRules(fHistoricRules, rbtz->fHistoricRules)
103 && compareRules(fFinalRules, rbtz->fFinalRules)) {
104 return TRUE;
105 }
106 return FALSE;
107 }
108
109 UBool
110 RuleBasedTimeZone::operator!=(const TimeZone& that) const {
111 return !operator==(that);
112 }
113
114 void
115 RuleBasedTimeZone::addTransitionRule(TimeZoneRule* rule, UErrorCode& status) {
116 if (U_FAILURE(status)) {
117 return;
118 }
119 AnnualTimeZoneRule* atzrule = dynamic_cast<AnnualTimeZoneRule*>(rule);
120 if (atzrule != NULL && atzrule->getEndYear() == AnnualTimeZoneRule::MAX_YEAR) {
121 // A final rule
122 if (fFinalRules == NULL) {
123 fFinalRules = new UVector(status);
124 if (U_FAILURE(status)) {
125 return;
126 }
127 } else if (fFinalRules->size() >= 2) {
128 // Cannot handle more than two final rules
129 status = U_INVALID_STATE_ERROR;
130 return;
131 }
132 fFinalRules->addElement((void*)rule, status);
133 } else {
134 // Non-final rule
135 if (fHistoricRules == NULL) {
136 fHistoricRules = new UVector(status);
137 if (U_FAILURE(status)) {
138 return;
139 }
140 }
141 fHistoricRules->addElement((void*)rule, status);
142 }
143 // Mark dirty, so transitions are recalculated at next complete() call
144 fUpToDate = FALSE;
145 }
146
147 static UMutex gLock = U_MUTEX_INITIALIZER;
148
149 void
150 RuleBasedTimeZone::completeConst(UErrorCode& status) const {
151 if (U_FAILURE(status)) {
152 return;
153 }
154 umtx_lock(&gLock);
155 if (!fUpToDate) {
156 RuleBasedTimeZone *ncThis = const_cast<RuleBasedTimeZone*>(this);
157 ncThis->complete(status);
158 }
159 umtx_unlock(&gLock);
160 }
161
162 void
163 RuleBasedTimeZone::complete(UErrorCode& status) {
164 if (U_FAILURE(status)) {
165 return;
166 }
167 if (fUpToDate) {
168 return;
169 }
170 // Make sure either no final rules or a pair of AnnualTimeZoneRules
171 // are available.
172 if (fFinalRules != NULL && fFinalRules->size() != 2) {
173 status = U_INVALID_STATE_ERROR;
174 return;
175 }
176
177 UBool *done = NULL;
178 // Create a TimezoneTransition and add to the list
179 if (fHistoricRules != NULL || fFinalRules != NULL) {
180 TimeZoneRule *curRule = fInitialRule;
181 UDate lastTransitionTime = MIN_MILLIS;
182
183 // Build the transition array which represents historical time zone
184 // transitions.
185 if (fHistoricRules != NULL && fHistoricRules->size() > 0) {
186 int32_t i;
187 int32_t historicCount = fHistoricRules->size();
188 done = (UBool*)uprv_malloc(sizeof(UBool) * historicCount);
189 if (done == NULL) {
190 status = U_MEMORY_ALLOCATION_ERROR;
191 goto cleanup;
192 }
193 for (i = 0; i < historicCount; i++) {
194 done[i] = FALSE;
195 }
196 while (TRUE) {
197 int32_t curStdOffset = curRule->getRawOffset();
198 int32_t curDstSavings = curRule->getDSTSavings();
199 UDate nextTransitionTime = MAX_MILLIS;
200 TimeZoneRule *nextRule = NULL;
201 TimeZoneRule *r = NULL;
202 UBool avail;
203 UDate tt;
204 UnicodeString curName, name;
205 curRule->getName(curName);
206
207 for (i = 0; i < historicCount; i++) {
208 if (done[i]) {
209 continue;
210 }
211 r = (TimeZoneRule*)fHistoricRules->elementAt(i);
212 avail = r->getNextStart(lastTransitionTime, curStdOffset, curDstSavings, false, tt);
213 if (!avail) {
214 // No more transitions from this rule - skip this rule next time
215 done[i] = TRUE;
216 } else {
217 r->getName(name);
218 if (*r == *curRule ||
219 (name == curName && r->getRawOffset() == curRule->getRawOffset()
220 && r->getDSTSavings() == curRule->getDSTSavings())) {
221 continue;
222 }
223 if (tt < nextTransitionTime) {
224 nextTransitionTime = tt;
225 nextRule = r;
226 }
227 }
228 }
229
230 if (nextRule == NULL) {
231 // Check if all historic rules are done
232 UBool bDoneAll = TRUE;
233 for (int32_t j = 0; j < historicCount; j++) {
234 if (!done[j]) {
235 bDoneAll = FALSE;
236 break;
237 }
238 }
239 if (bDoneAll) {
240 break;
241 }
242 }
243
244 if (fFinalRules != NULL) {
245 // Check if one of final rules has earlier transition date
246 for (i = 0; i < 2 /* fFinalRules->size() */; i++) {
247 TimeZoneRule *fr = (TimeZoneRule*)fFinalRules->elementAt(i);
248 if (*fr == *curRule) {
249 continue;
250 }
251 r = (TimeZoneRule*)fFinalRules->elementAt(i);
252 avail = r->getNextStart(lastTransitionTime, curStdOffset, curDstSavings, false, tt);
253 if (avail) {
254 if (tt < nextTransitionTime) {
255 nextTransitionTime = tt;
256 nextRule = r;
257 }
258 }
259 }
260 }
261
262 if (nextRule == NULL) {
263 // Nothing more
264 break;
265 }
266
267 if (fHistoricTransitions == NULL) {
268 fHistoricTransitions = new UVector(status);
269 if (U_FAILURE(status)) {
270 goto cleanup;
271 }
272 }
273 Transition *trst = (Transition*)uprv_malloc(sizeof(Transition));
274 if (trst == NULL) {
275 status = U_MEMORY_ALLOCATION_ERROR;
276 goto cleanup;
277 }
278 trst->time = nextTransitionTime;
279 trst->from = curRule;
280 trst->to = nextRule;
281 fHistoricTransitions->addElement(trst, status);
282 if (U_FAILURE(status)) {
283 goto cleanup;
284 }
285 lastTransitionTime = nextTransitionTime;
286 curRule = nextRule;
287 }
288 }
289 if (fFinalRules != NULL) {
290 if (fHistoricTransitions == NULL) {
291 fHistoricTransitions = new UVector(status);
292 if (U_FAILURE(status)) {
293 goto cleanup;
294 }
295 }
296 // Append the first transition for each
297 TimeZoneRule *rule0 = (TimeZoneRule*)fFinalRules->elementAt(0);
298 TimeZoneRule *rule1 = (TimeZoneRule*)fFinalRules->elementAt(1);
299 UDate tt0, tt1;
300 UBool avail0 = rule0->getNextStart(lastTransitionTime, curRule->getRawOffset(), curRule->getDSTSavings(), false, tt0);
301 UBool avail1 = rule1->getNextStart(lastTransitionTime, curRule->getRawOffset(), curRule->getDSTSavings(), false, tt1);
302 if (!avail0 || !avail1) {
303 // Should not happen, because both rules are permanent
304 status = U_INVALID_STATE_ERROR;
305 goto cleanup;
306 }
307 Transition *final0 = (Transition*)uprv_malloc(sizeof(Transition));
308 if (final0 == NULL) {
309 status = U_MEMORY_ALLOCATION_ERROR;
310 goto cleanup;
311 }
312 Transition *final1 = (Transition*)uprv_malloc(sizeof(Transition));
313 if (final1 == NULL) {
314 uprv_free(final0);
315 status = U_MEMORY_ALLOCATION_ERROR;
316 goto cleanup;
317 }
318 if (tt0 < tt1) {
319 final0->time = tt0;
320 final0->from = curRule;
321 final0->to = rule0;
322 rule1->getNextStart(tt0, rule0->getRawOffset(), rule0->getDSTSavings(), false, final1->time);
323 final1->from = rule0;
324 final1->to = rule1;
325 } else {
326 final0->time = tt1;
327 final0->from = curRule;
328 final0->to = rule1;
329 rule0->getNextStart(tt1, rule1->getRawOffset(), rule1->getDSTSavings(), false, final1->time);
330 final1->from = rule1;
331 final1->to = rule0;
332 }
333 fHistoricTransitions->addElement(final0, status);
334 if (U_FAILURE(status)) {
335 goto cleanup;
336 }
337 fHistoricTransitions->addElement(final1, status);
338 if (U_FAILURE(status)) {
339 goto cleanup;
340 }
341 }
342 }
343 fUpToDate = TRUE;
344 if (done != NULL) {
345 uprv_free(done);
346 }
347 return;
348
349 cleanup:
350 deleteTransitions();
351 if (done != NULL) {
352 uprv_free(done);
353 }
354 fUpToDate = FALSE;
355 }
356
357 TimeZone*
358 RuleBasedTimeZone::clone(void) const {
359 return new RuleBasedTimeZone(*this);
360 }
361
362 int32_t
363 RuleBasedTimeZone::getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
364 uint8_t dayOfWeek, int32_t millis, UErrorCode& status) const {
365 if (U_FAILURE(status)) {
366 return 0;
367 }
368 if (month < UCAL_JANUARY || month > UCAL_DECEMBER) {
369 status = U_ILLEGAL_ARGUMENT_ERROR;
370 return 0;
371 } else {
372 return getOffset(era, year, month, day, dayOfWeek, millis,
373 Grego::monthLength(year, month), status);
374 }
375 }
376
377 int32_t
378 RuleBasedTimeZone::getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
379 uint8_t /*dayOfWeek*/, int32_t millis,
380 int32_t /*monthLength*/, UErrorCode& status) const {
381 // dayOfWeek and monthLength are unused
382 if (U_FAILURE(status)) {
383 return 0;
384 }
385 if (era == GregorianCalendar::BC) {
386 // Convert to extended year
387 year = 1 - year;
388 }
389 int32_t rawOffset, dstOffset;
390 UDate time = (UDate)Grego::fieldsToDay(year, month, day) * U_MILLIS_PER_DAY + millis;
391 getOffsetInternal(time, TRUE, kDaylight, kStandard, rawOffset, dstOffset, status);
392 if (U_FAILURE(status)) {
393 return 0;
394 }
395 return (rawOffset + dstOffset);
396 }
397
398 void
399 RuleBasedTimeZone::getOffset(UDate date, UBool local, int32_t& rawOffset,
400 int32_t& dstOffset, UErrorCode& status) const {
401 getOffsetInternal(date, local, kFormer, kLatter, rawOffset, dstOffset, status);
402 }
403
404 void
405 RuleBasedTimeZone::getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
406 int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) const {
407 getOffsetInternal(date, TRUE, nonExistingTimeOpt, duplicatedTimeOpt, rawOffset, dstOffset, status);
408 }
409
410
411 /*
412 * The internal getOffset implementation
413 */
414 void
415 RuleBasedTimeZone::getOffsetInternal(UDate date, UBool local,
416 int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt,
417 int32_t& rawOffset, int32_t& dstOffset,
418 UErrorCode& status) const {
419 rawOffset = 0;
420 dstOffset = 0;
421
422 if (U_FAILURE(status)) {
423 return;
424 }
425 if (!fUpToDate) {
426 // Transitions are not yet resolved. We cannot do it here
427 // because this method is const. Thus, do nothing and return
428 // error status.
429 status = U_INVALID_STATE_ERROR;
430 return;
431 }
432 const TimeZoneRule *rule = NULL;
433 if (fHistoricTransitions == NULL) {
434 rule = fInitialRule;
435 } else {
436 UDate tstart = getTransitionTime((Transition*)fHistoricTransitions->elementAt(0),
437 local, NonExistingTimeOpt, DuplicatedTimeOpt);
438 if (date < tstart) {
439 rule = fInitialRule;
440 } else {
441 int32_t idx = fHistoricTransitions->size() - 1;
442 UDate tend = getTransitionTime((Transition*)fHistoricTransitions->elementAt(idx),
443 local, NonExistingTimeOpt, DuplicatedTimeOpt);
444 if (date > tend) {
445 if (fFinalRules != NULL) {
446 rule = findRuleInFinal(date, local, NonExistingTimeOpt, DuplicatedTimeOpt);
447 }
448 if (rule == NULL) {
449 // no final rules or the given time is before the first transition
450 // specified by the final rules -> use the last rule
451 rule = ((Transition*)fHistoricTransitions->elementAt(idx))->to;
452 }
453 } else {
454 // Find a historical transition
455 while (idx >= 0) {
456 if (date >= getTransitionTime((Transition*)fHistoricTransitions->elementAt(idx),
457 local, NonExistingTimeOpt, DuplicatedTimeOpt)) {
458 break;
459 }
460 idx--;
461 }
462 rule = ((Transition*)fHistoricTransitions->elementAt(idx))->to;
463 }
464 }
465 }
466 if (rule != NULL) {
467 rawOffset = rule->getRawOffset();
468 dstOffset = rule->getDSTSavings();
469 }
470 }
471
472 void
473 RuleBasedTimeZone::setRawOffset(int32_t /*offsetMillis*/) {
474 // We don't support this operation at this moment.
475 // Nothing to do!
476 }
477
478 int32_t
479 RuleBasedTimeZone::getRawOffset(void) const {
480 // Note: This implementation returns standard GMT offset
481 // as of current time.
482 UErrorCode status = U_ZERO_ERROR;
483 int32_t raw, dst;
484 getOffset(uprv_getUTCtime() * U_MILLIS_PER_SECOND,
485 FALSE, raw, dst, status);
486 return raw;
487 }
488
489 UBool
490 RuleBasedTimeZone::useDaylightTime(void) const {
491 // Note: This implementation returns true when
492 // daylight saving time is used as of now or
493 // after the next transition.
494 UErrorCode status = U_ZERO_ERROR;
495 UDate now = uprv_getUTCtime() * U_MILLIS_PER_SECOND;
496 int32_t raw, dst;
497 getOffset(now, FALSE, raw, dst, status);
498 if (dst != 0) {
499 return TRUE;
500 }
501 // If DST is not used now, check if DST is used after the next transition
502 UDate time;
503 TimeZoneRule *from, *to;
504 UBool avail = findNext(now, FALSE, time, from, to);
505 if (avail && to->getDSTSavings() != 0) {
506 return TRUE;
507 }
508 return FALSE;
509 }
510
511 UBool
512 RuleBasedTimeZone::inDaylightTime(UDate date, UErrorCode& status) const {
513 if (U_FAILURE(status)) {
514 return FALSE;
515 }
516 int32_t raw, dst;
517 getOffset(date, FALSE, raw, dst, status);
518 if (dst != 0) {
519 return TRUE;
520 }
521 return FALSE;
522 }
523
524 UBool
525 RuleBasedTimeZone::hasSameRules(const TimeZone& other) const {
526 if (this == &other) {
527 return TRUE;
528 }
529 if (typeid(*this) != typeid(other)) {
530 return FALSE;
531 }
532 const RuleBasedTimeZone& that = (const RuleBasedTimeZone&)other;
533 if (*fInitialRule != *(that.fInitialRule)) {
534 return FALSE;
535 }
536 if (compareRules(fHistoricRules, that.fHistoricRules)
537 && compareRules(fFinalRules, that.fFinalRules)) {
538 return TRUE;
539 }
540 return FALSE;
541 }
542
543 UBool
544 RuleBasedTimeZone::getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const {
545 UErrorCode status = U_ZERO_ERROR;
546 completeConst(status);
547 if (U_FAILURE(status)) {
548 return FALSE;
549 }
550 UDate transitionTime;
551 TimeZoneRule *fromRule, *toRule;
552 UBool found = findNext(base, inclusive, transitionTime, fromRule, toRule);
553 if (found) {
554 result.setTime(transitionTime);
555 result.setFrom((const TimeZoneRule&)*fromRule);
556 result.setTo((const TimeZoneRule&)*toRule);
557 return TRUE;
558 }
559 return FALSE;
560 }
561
562 UBool
563 RuleBasedTimeZone::getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const {
564 UErrorCode status = U_ZERO_ERROR;
565 completeConst(status);
566 if (U_FAILURE(status)) {
567 return FALSE;
568 }
569 UDate transitionTime;
570 TimeZoneRule *fromRule, *toRule;
571 UBool found = findPrev(base, inclusive, transitionTime, fromRule, toRule);
572 if (found) {
573 result.setTime(transitionTime);
574 result.setFrom((const TimeZoneRule&)*fromRule);
575 result.setTo((const TimeZoneRule&)*toRule);
576 return TRUE;
577 }
578 return FALSE;
579 }
580
581 int32_t
582 RuleBasedTimeZone::countTransitionRules(UErrorCode& /*status*/) const {
583 int32_t count = 0;
584 if (fHistoricRules != NULL) {
585 count += fHistoricRules->size();
586 }
587 if (fFinalRules != NULL) {
588 count += fFinalRules->size();
589 }
590 return count;
591 }
592
593 void
594 RuleBasedTimeZone::getTimeZoneRules(const InitialTimeZoneRule*& initial,
595 const TimeZoneRule* trsrules[],
596 int32_t& trscount,
597 UErrorCode& status) const {
598 if (U_FAILURE(status)) {
599 return;
600 }
601 // Initial rule
602 initial = fInitialRule;
603
604 // Transition rules
605 int32_t cnt = 0;
606 int32_t idx;
607 if (fHistoricRules != NULL && cnt < trscount) {
608 int32_t historicCount = fHistoricRules->size();
609 idx = 0;
610 while (cnt < trscount && idx < historicCount) {
611 trsrules[cnt++] = (const TimeZoneRule*)fHistoricRules->elementAt(idx++);
612 }
613 }
614 if (fFinalRules != NULL && cnt < trscount) {
615 int32_t finalCount = fFinalRules->size();
616 idx = 0;
617 while (cnt < trscount && idx < finalCount) {
618 trsrules[cnt++] = (const TimeZoneRule*)fFinalRules->elementAt(idx++);
619 }
620 }
621 // Set the result length
622 trscount = cnt;
623 }
624
625 void
626 RuleBasedTimeZone::deleteRules(void) {
627 delete fInitialRule;
628 fInitialRule = NULL;
629 if (fHistoricRules != NULL) {
630 while (!fHistoricRules->isEmpty()) {
631 delete (TimeZoneRule*)(fHistoricRules->orphanElementAt(0));
632 }
633 delete fHistoricRules;
634 fHistoricRules = NULL;
635 }
636 if (fFinalRules != NULL) {
637 while (!fFinalRules->isEmpty()) {
638 delete (AnnualTimeZoneRule*)(fFinalRules->orphanElementAt(0));
639 }
640 delete fFinalRules;
641 fFinalRules = NULL;
642 }
643 }
644
645 void
646 RuleBasedTimeZone::deleteTransitions(void) {
647 if (fHistoricTransitions != NULL) {
648 while (!fHistoricTransitions->isEmpty()) {
649 Transition *trs = (Transition*)fHistoricTransitions->orphanElementAt(0);
650 uprv_free(trs);
651 }
652 delete fHistoricTransitions;
653 }
654 fHistoricTransitions = NULL;
655 }
656
657 UVector*
658 RuleBasedTimeZone::copyRules(UVector* source) {
659 if (source == NULL) {
660 return NULL;
661 }
662 UErrorCode ec = U_ZERO_ERROR;
663 int32_t size = source->size();
664 UVector *rules = new UVector(size, ec);
665 if (U_FAILURE(ec)) {
666 return NULL;
667 }
668 int32_t i;
669 for (i = 0; i < size; i++) {
670 rules->addElement(((TimeZoneRule*)source->elementAt(i))->clone(), ec);
671 if (U_FAILURE(ec)) {
672 break;
673 }
674 }
675 if (U_FAILURE(ec)) {
676 // In case of error, clean up
677 for (i = 0; i < rules->size(); i++) {
678 TimeZoneRule *rule = (TimeZoneRule*)rules->orphanElementAt(i);
679 delete rule;
680 }
681 delete rules;
682 return NULL;
683 }
684 return rules;
685 }
686
687 TimeZoneRule*
688 RuleBasedTimeZone::findRuleInFinal(UDate date, UBool local,
689 int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt) const {
690 if (fFinalRules == NULL) {
691 return NULL;
692 }
693
694 AnnualTimeZoneRule* fr0 = (AnnualTimeZoneRule*)fFinalRules->elementAt(0);
695 AnnualTimeZoneRule* fr1 = (AnnualTimeZoneRule*)fFinalRules->elementAt(1);
696 if (fr0 == NULL || fr1 == NULL) {
697 return NULL;
698 }
699
700 UDate start0, start1;
701 UDate base;
702 int32_t localDelta;
703
704 base = date;
705 if (local) {
706 localDelta = getLocalDelta(fr1->getRawOffset(), fr1->getDSTSavings(),
707 fr0->getRawOffset(), fr0->getDSTSavings(),
708 NonExistingTimeOpt, DuplicatedTimeOpt);
709 base -= localDelta;
710 }
711 UBool avail0 = fr0->getPreviousStart(base, fr1->getRawOffset(), fr1->getDSTSavings(), TRUE, start0);
712
713 base = date;
714 if (local) {
715 localDelta = getLocalDelta(fr0->getRawOffset(), fr0->getDSTSavings(),
716 fr1->getRawOffset(), fr1->getDSTSavings(),
717 NonExistingTimeOpt, DuplicatedTimeOpt);
718 base -= localDelta;
719 }
720 UBool avail1 = fr1->getPreviousStart(base, fr0->getRawOffset(), fr0->getDSTSavings(), TRUE, start1);
721
722 if (!avail0 || !avail1) {
723 if (avail0) {
724 return fr0;
725 } else if (avail1) {
726 return fr1;
727 }
728 // Both rules take effect after the given time
729 return NULL;
730 }
731
732 return (start0 > start1) ? fr0 : fr1;
733 }
734
735 UBool
736 RuleBasedTimeZone::findNext(UDate base, UBool inclusive, UDate& transitionTime,
737 TimeZoneRule*& fromRule, TimeZoneRule*& toRule) const {
738 if (fHistoricTransitions == NULL) {
739 return FALSE;
740 }
741 UBool isFinal = FALSE;
742 UBool found = FALSE;
743 Transition result;
744 Transition *tzt = (Transition*)fHistoricTransitions->elementAt(0);
745 UDate tt = tzt->time;
746 if (tt > base || (inclusive && tt == base)) {
747 result = *tzt;
748 found = TRUE;
749 } else {
750 int32_t idx = fHistoricTransitions->size() - 1;
751 tzt = (Transition*)fHistoricTransitions->elementAt(idx);
752 tt = tzt->time;
753 if (inclusive && tt == base) {
754 result = *tzt;
755 found = TRUE;
756 } else if (tt <= base) {
757 if (fFinalRules != NULL) {
758 // Find a transion time with finalRules
759 TimeZoneRule *r0 = (TimeZoneRule*)fFinalRules->elementAt(0);
760 TimeZoneRule *r1 = (TimeZoneRule*)fFinalRules->elementAt(1);
761 UDate start0, start1;
762 UBool avail0 = r0->getNextStart(base, r1->getRawOffset(), r1->getDSTSavings(), inclusive, start0);
763 UBool avail1 = r1->getNextStart(base, r0->getRawOffset(), r0->getDSTSavings(), inclusive, start1);
764 // avail0/avail1 should be always TRUE
765 if (!avail0 && !avail1) {
766 return FALSE;
767 }
768 if (!avail1 || start0 < start1) {
769 result.time = start0;
770 result.from = r1;
771 result.to = r0;
772 } else {
773 result.time = start1;
774 result.from = r0;
775 result.to = r1;
776 }
777 isFinal = TRUE;
778 found = TRUE;
779 }
780 } else {
781 // Find a transition within the historic transitions
782 idx--;
783 Transition *prev = tzt;
784 while (idx > 0) {
785 tzt = (Transition*)fHistoricTransitions->elementAt(idx);
786 tt = tzt->time;
787 if (tt < base || (!inclusive && tt == base)) {
788 break;
789 }
790 idx--;
791 prev = tzt;
792 }
793 result.time = prev->time;
794 result.from = prev->from;
795 result.to = prev->to;
796 found = TRUE;
797 }
798 }
799 if (found) {
800 // For now, this implementation ignore transitions with only zone name changes.
801 if (result.from->getRawOffset() == result.to->getRawOffset()
802 && result.from->getDSTSavings() == result.to->getDSTSavings()) {
803 if (isFinal) {
804 return FALSE;
805 } else {
806 // No offset changes. Try next one if not final
807 return findNext(result.time, FALSE /* always exclusive */,
808 transitionTime, fromRule, toRule);
809 }
810 }
811 transitionTime = result.time;
812 fromRule = result.from;
813 toRule = result.to;
814 return TRUE;
815 }
816 return FALSE;
817 }
818
819 UBool
820 RuleBasedTimeZone::findPrev(UDate base, UBool inclusive, UDate& transitionTime,
821 TimeZoneRule*& fromRule, TimeZoneRule*& toRule) const {
822 if (fHistoricTransitions == NULL) {
823 return FALSE;
824 }
825 UBool found = FALSE;
826 Transition result;
827 Transition *tzt = (Transition*)fHistoricTransitions->elementAt(0);
828 UDate tt = tzt->time;
829 if (inclusive && tt == base) {
830 result = *tzt;
831 found = TRUE;
832 } else if (tt < base) {
833 int32_t idx = fHistoricTransitions->size() - 1;
834 tzt = (Transition*)fHistoricTransitions->elementAt(idx);
835 tt = tzt->time;
836 if (inclusive && tt == base) {
837 result = *tzt;
838 found = TRUE;
839 } else if (tt < base) {
840 if (fFinalRules != NULL) {
841 // Find a transion time with finalRules
842 TimeZoneRule *r0 = (TimeZoneRule*)fFinalRules->elementAt(0);
843 TimeZoneRule *r1 = (TimeZoneRule*)fFinalRules->elementAt(1);
844 UDate start0, start1;
845 UBool avail0 = r0->getPreviousStart(base, r1->getRawOffset(), r1->getDSTSavings(), inclusive, start0);
846 UBool avail1 = r1->getPreviousStart(base, r0->getRawOffset(), r0->getDSTSavings(), inclusive, start1);
847 // avail0/avail1 should be always TRUE
848 if (!avail0 && !avail1) {
849 return FALSE;
850 }
851 if (!avail1 || start0 > start1) {
852 result.time = start0;
853 result.from = r1;
854 result.to = r0;
855 } else {
856 result.time = start1;
857 result.from = r0;
858 result.to = r1;
859 }
860 } else {
861 result = *tzt;
862 }
863 found = TRUE;
864 } else {
865 // Find a transition within the historic transitions
866 idx--;
867 while (idx >= 0) {
868 tzt = (Transition*)fHistoricTransitions->elementAt(idx);
869 tt = tzt->time;
870 if (tt < base || (inclusive && tt == base)) {
871 break;
872 }
873 idx--;
874 }
875 result = *tzt;
876 found = TRUE;
877 }
878 }
879 if (found) {
880 // For now, this implementation ignore transitions with only zone name changes.
881 if (result.from->getRawOffset() == result.to->getRawOffset()
882 && result.from->getDSTSavings() == result.to->getDSTSavings()) {
883 // No offset changes. Try next one if not final
884 return findPrev(result.time, FALSE /* always exclusive */,
885 transitionTime, fromRule, toRule);
886 }
887 transitionTime = result.time;
888 fromRule = result.from;
889 toRule = result.to;
890 return TRUE;
891 }
892 return FALSE;
893 }
894
895 UDate
896 RuleBasedTimeZone::getTransitionTime(Transition* transition, UBool local,
897 int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt) const {
898 UDate time = transition->time;
899 if (local) {
900 time += getLocalDelta(transition->from->getRawOffset(), transition->from->getDSTSavings(),
901 transition->to->getRawOffset(), transition->to->getDSTSavings(),
902 NonExistingTimeOpt, DuplicatedTimeOpt);
903 }
904 return time;
905 }
906
907 int32_t
908 RuleBasedTimeZone::getLocalDelta(int32_t rawBefore, int32_t dstBefore, int32_t rawAfter, int32_t dstAfter,
909 int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt) const {
910 int32_t delta = 0;
911
912 int32_t offsetBefore = rawBefore + dstBefore;
913 int32_t offsetAfter = rawAfter + dstAfter;
914
915 UBool dstToStd = (dstBefore != 0) && (dstAfter == 0);
916 UBool stdToDst = (dstBefore == 0) && (dstAfter != 0);
917
918 if (offsetAfter - offsetBefore >= 0) {
919 // Positive transition, which makes a non-existing local time range
920 if (((NonExistingTimeOpt & kStdDstMask) == kStandard && dstToStd)
921 || ((NonExistingTimeOpt & kStdDstMask) == kDaylight && stdToDst)) {
922 delta = offsetBefore;
923 } else if (((NonExistingTimeOpt & kStdDstMask) == kStandard && stdToDst)
924 || ((NonExistingTimeOpt & kStdDstMask) == kDaylight && dstToStd)) {
925 delta = offsetAfter;
926 } else if ((NonExistingTimeOpt & kFormerLatterMask) == kLatter) {
927 delta = offsetBefore;
928 } else {
929 // Interprets the time with rule before the transition,
930 // default for non-existing time range
931 delta = offsetAfter;
932 }
933 } else {
934 // Negative transition, which makes a duplicated local time range
935 if (((DuplicatedTimeOpt & kStdDstMask) == kStandard && dstToStd)
936 || ((DuplicatedTimeOpt & kStdDstMask) == kDaylight && stdToDst)) {
937 delta = offsetAfter;
938 } else if (((DuplicatedTimeOpt & kStdDstMask) == kStandard && stdToDst)
939 || ((DuplicatedTimeOpt & kStdDstMask) == kDaylight && dstToStd)) {
940 delta = offsetBefore;
941 } else if ((DuplicatedTimeOpt & kFormerLatterMask) == kFormer) {
942 delta = offsetBefore;
943 } else {
944 // Interprets the time with rule after the transition,
945 // default for duplicated local time range
946 delta = offsetAfter;
947 }
948 }
949 return delta;
950 }
951
952 U_NAMESPACE_END
953
954 #endif /* #if !UCONFIG_NO_FORMATTING */
955
956 //eof
957

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial