The Tor Browser / file comparison

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

intl/icu/source/i18n/tzrule.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:a5d5830bb74f
1 /*
2 *******************************************************************************
3 * Copyright (C) 2007-2012, 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/tzrule.h"
15 #include "unicode/ucal.h"
16 #include "gregoimp.h"
17 #include "cmemory.h"
18 #include "uarrsort.h"
19
20 U_CDECL_BEGIN
21 // UComparator function for sorting start times
22 static int32_t U_CALLCONV
23 compareDates(const void * /*context*/, const void *left, const void *right) {
24 UDate l = *((UDate*)left);
25 UDate r = *((UDate*)right);
26 int32_t res = l < r ? -1 : (l == r ? 0 : 1);
27 return res;
28 }
29 U_CDECL_END
30
31 U_NAMESPACE_BEGIN
32
33 TimeZoneRule::TimeZoneRule(const UnicodeString& name, int32_t rawOffset, int32_t dstSavings)
34 : UObject(), fName(name), fRawOffset(rawOffset), fDSTSavings(dstSavings) {
35 }
36
37 TimeZoneRule::TimeZoneRule(const TimeZoneRule& source)
38 : UObject(source), fName(source.fName), fRawOffset(source.fRawOffset), fDSTSavings(source.fDSTSavings) {
39 }
40
41 TimeZoneRule::~TimeZoneRule() {
42 }
43
44 TimeZoneRule&
45 TimeZoneRule::operator=(const TimeZoneRule& right) {
46 if (this != &right) {
47 fName = right.fName;
48 fRawOffset = right.fRawOffset;
49 fDSTSavings = right.fDSTSavings;
50 }
51 return *this;
52 }
53
54 UBool
55 TimeZoneRule::operator==(const TimeZoneRule& that) const {
56 return ((this == &that) ||
57 (typeid(*this) == typeid(that) &&
58 fName == that.fName &&
59 fRawOffset == that.fRawOffset &&
60 fDSTSavings == that.fDSTSavings));
61 }
62
63 UBool
64 TimeZoneRule::operator!=(const TimeZoneRule& that) const {
65 return !operator==(that);
66 }
67
68 UnicodeString&
69 TimeZoneRule::getName(UnicodeString& name) const {
70 name = fName;
71 return name;
72 }
73
74 int32_t
75 TimeZoneRule::getRawOffset(void) const {
76 return fRawOffset;
77 }
78
79 int32_t
80 TimeZoneRule::getDSTSavings(void) const {
81 return fDSTSavings;
82 }
83
84 UBool
85 TimeZoneRule::isEquivalentTo(const TimeZoneRule& other) const {
86 return ((this == &other) ||
87 (typeid(*this) == typeid(other) &&
88 fRawOffset == other.fRawOffset &&
89 fDSTSavings == other.fDSTSavings));
90 }
91
92
93 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(InitialTimeZoneRule)
94
95 InitialTimeZoneRule::InitialTimeZoneRule(const UnicodeString& name,
96 int32_t rawOffset,
97 int32_t dstSavings)
98 : TimeZoneRule(name, rawOffset, dstSavings) {
99 }
100
101 InitialTimeZoneRule::InitialTimeZoneRule(const InitialTimeZoneRule& source)
102 : TimeZoneRule(source) {
103 }
104
105 InitialTimeZoneRule::~InitialTimeZoneRule() {
106 }
107
108 InitialTimeZoneRule*
109 InitialTimeZoneRule::clone(void) const {
110 return new InitialTimeZoneRule(*this);
111 }
112
113 InitialTimeZoneRule&
114 InitialTimeZoneRule::operator=(const InitialTimeZoneRule& right) {
115 if (this != &right) {
116 TimeZoneRule::operator=(right);
117 }
118 return *this;
119 }
120
121 UBool
122 InitialTimeZoneRule::operator==(const TimeZoneRule& that) const {
123 return ((this == &that) ||
124 (typeid(*this) == typeid(that) &&
125 TimeZoneRule::operator==(that)));
126 }
127
128 UBool
129 InitialTimeZoneRule::operator!=(const TimeZoneRule& that) const {
130 return !operator==(that);
131 }
132
133 UBool
134 InitialTimeZoneRule::isEquivalentTo(const TimeZoneRule& other) const {
135 if (this == &other) {
136 return TRUE;
137 }
138 if (typeid(*this) != typeid(other) || TimeZoneRule::isEquivalentTo(other) == FALSE) {
139 return FALSE;
140 }
141 return TRUE;
142 }
143
144 UBool
145 InitialTimeZoneRule::getFirstStart(int32_t /*prevRawOffset*/,
146 int32_t /*prevDSTSavings*/,
147 UDate& /*result*/) const {
148 return FALSE;
149 }
150
151 UBool
152 InitialTimeZoneRule::getFinalStart(int32_t /*prevRawOffset*/,
153 int32_t /*prevDSTSavings*/,
154 UDate& /*result*/) const {
155 return FALSE;
156 }
157
158 UBool
159 InitialTimeZoneRule::getNextStart(UDate /*base*/,
160 int32_t /*prevRawOffset*/,
161 int32_t /*prevDSTSavings*/,
162 UBool /*inclusive*/,
163 UDate& /*result*/) const {
164 return FALSE;
165 }
166
167 UBool
168 InitialTimeZoneRule::getPreviousStart(UDate /*base*/,
169 int32_t /*prevRawOffset*/,
170 int32_t /*prevDSTSavings*/,
171 UBool /*inclusive*/,
172 UDate& /*result*/) const {
173 return FALSE;
174 }
175
176
177 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(AnnualTimeZoneRule)
178
179 const int32_t AnnualTimeZoneRule::MAX_YEAR = 0x7FFFFFFF; /* max signed int32 */
180
181 AnnualTimeZoneRule::AnnualTimeZoneRule(const UnicodeString& name,
182 int32_t rawOffset,
183 int32_t dstSavings,
184 const DateTimeRule& dateTimeRule,
185 int32_t startYear,
186 int32_t endYear)
187 : TimeZoneRule(name, rawOffset, dstSavings), fDateTimeRule(new DateTimeRule(dateTimeRule)),
188 fStartYear(startYear), fEndYear(endYear) {
189 }
190
191 AnnualTimeZoneRule::AnnualTimeZoneRule(const UnicodeString& name,
192 int32_t rawOffset,
193 int32_t dstSavings,
194 DateTimeRule* dateTimeRule,
195 int32_t startYear,
196 int32_t endYear)
197 : TimeZoneRule(name, rawOffset, dstSavings), fDateTimeRule(dateTimeRule),
198 fStartYear(startYear), fEndYear(endYear) {
199 }
200
201 AnnualTimeZoneRule::AnnualTimeZoneRule(const AnnualTimeZoneRule& source)
202 : TimeZoneRule(source), fDateTimeRule(new DateTimeRule(*(source.fDateTimeRule))),
203 fStartYear(source.fStartYear), fEndYear(source.fEndYear) {
204 }
205
206 AnnualTimeZoneRule::~AnnualTimeZoneRule() {
207 delete fDateTimeRule;
208 }
209
210 AnnualTimeZoneRule*
211 AnnualTimeZoneRule::clone(void) const {
212 return new AnnualTimeZoneRule(*this);
213 }
214
215 AnnualTimeZoneRule&
216 AnnualTimeZoneRule::operator=(const AnnualTimeZoneRule& right) {
217 if (this != &right) {
218 TimeZoneRule::operator=(right);
219 delete fDateTimeRule;
220 fDateTimeRule = right.fDateTimeRule->clone();
221 fStartYear = right.fStartYear;
222 fEndYear = right.fEndYear;
223 }
224 return *this;
225 }
226
227 UBool
228 AnnualTimeZoneRule::operator==(const TimeZoneRule& that) const {
229 if (this == &that) {
230 return TRUE;
231 }
232 if (typeid(*this) != typeid(that)) {
233 return FALSE;
234 }
235 AnnualTimeZoneRule *atzr = (AnnualTimeZoneRule*)&that;
236 return (*fDateTimeRule == *(atzr->fDateTimeRule) &&
237 fStartYear == atzr->fStartYear &&
238 fEndYear == atzr->fEndYear);
239 }
240
241 UBool
242 AnnualTimeZoneRule::operator!=(const TimeZoneRule& that) const {
243 return !operator==(that);
244 }
245
246 const DateTimeRule*
247 AnnualTimeZoneRule::getRule() const {
248 return fDateTimeRule;
249 }
250
251 int32_t
252 AnnualTimeZoneRule::getStartYear() const {
253 return fStartYear;
254 }
255
256 int32_t
257 AnnualTimeZoneRule::getEndYear() const {
258 return fEndYear;
259 }
260
261 UBool
262 AnnualTimeZoneRule::getStartInYear(int32_t year,
263 int32_t prevRawOffset,
264 int32_t prevDSTSavings,
265 UDate &result) const {
266 if (year < fStartYear || year > fEndYear) {
267 return FALSE;
268 }
269 double ruleDay;
270 DateTimeRule::DateRuleType type = fDateTimeRule->getDateRuleType();
271 if (type == DateTimeRule::DOM) {
272 ruleDay = Grego::fieldsToDay(year, fDateTimeRule->getRuleMonth(), fDateTimeRule->getRuleDayOfMonth());
273 } else {
274 UBool after = TRUE;
275 if (type == DateTimeRule::DOW) {
276 // Normalize DOW rule into DOW_GEQ_DOM or DOW_LEQ_DOM
277 int32_t weeks = fDateTimeRule->getRuleWeekInMonth();
278 if (weeks > 0) {
279 ruleDay = Grego::fieldsToDay(year, fDateTimeRule->getRuleMonth(), 1);
280 ruleDay += 7 * (weeks - 1);
281 } else {
282 after = FALSE;
283 ruleDay = Grego::fieldsToDay(year, fDateTimeRule->getRuleMonth(),
284 Grego::monthLength(year, fDateTimeRule->getRuleMonth()));
285 ruleDay += 7 * (weeks + 1);
286 }
287 } else {
288 int32_t month = fDateTimeRule->getRuleMonth();
289 int32_t dom = fDateTimeRule->getRuleDayOfMonth();
290 if (type == DateTimeRule::DOW_LEQ_DOM) {
291 after = FALSE;
292 // Handle Feb <=29
293 if (month == UCAL_FEBRUARY && dom == 29 && !Grego::isLeapYear(year)) {
294 dom--;
295 }
296 }
297 ruleDay = Grego::fieldsToDay(year, month, dom);
298 }
299 int32_t dow = Grego::dayOfWeek(ruleDay);
300 int32_t delta = fDateTimeRule->getRuleDayOfWeek() - dow;
301 if (after) {
302 delta = delta < 0 ? delta + 7 : delta;
303 } else {
304 delta = delta > 0 ? delta - 7 : delta;
305 }
306 ruleDay += delta;
307 }
308
309 result = ruleDay*U_MILLIS_PER_DAY + fDateTimeRule->getRuleMillisInDay();
310 if (fDateTimeRule->getTimeRuleType() != DateTimeRule::UTC_TIME) {
311 result -= prevRawOffset;
312 }
313 if (fDateTimeRule->getTimeRuleType() == DateTimeRule::WALL_TIME) {
314 result -= prevDSTSavings;
315 }
316 return TRUE;
317 }
318
319 UBool
320 AnnualTimeZoneRule::isEquivalentTo(const TimeZoneRule& other) const {
321 if (this == &other) {
322 return TRUE;
323 }
324 if (typeid(*this) != typeid(other) || TimeZoneRule::isEquivalentTo(other) == FALSE) {
325 return FALSE;
326 }
327 AnnualTimeZoneRule* that = (AnnualTimeZoneRule*)&other;
328 return (*fDateTimeRule == *(that->fDateTimeRule) &&
329 fStartYear == that->fStartYear &&
330 fEndYear == that->fEndYear);
331 }
332
333 UBool
334 AnnualTimeZoneRule::getFirstStart(int32_t prevRawOffset,
335 int32_t prevDSTSavings,
336 UDate& result) const {
337 return getStartInYear(fStartYear, prevRawOffset, prevDSTSavings, result);
338 }
339
340 UBool
341 AnnualTimeZoneRule::getFinalStart(int32_t prevRawOffset,
342 int32_t prevDSTSavings,
343 UDate& result) const {
344 if (fEndYear == MAX_YEAR) {
345 return FALSE;
346 }
347 return getStartInYear(fEndYear, prevRawOffset, prevDSTSavings, result);
348 }
349
350 UBool
351 AnnualTimeZoneRule::getNextStart(UDate base,
352 int32_t prevRawOffset,
353 int32_t prevDSTSavings,
354 UBool inclusive,
355 UDate& result) const {
356 int32_t year, month, dom, dow, doy, mid;
357 Grego::timeToFields(base, year, month, dom, dow, doy, mid);
358 if (year < fStartYear) {
359 return getFirstStart(prevRawOffset, prevDSTSavings, result);
360 }
361 UDate tmp;
362 if (getStartInYear(year, prevRawOffset, prevDSTSavings, tmp)) {
363 if (tmp < base || (!inclusive && (tmp == base))) {
364 // Return the next one
365 return getStartInYear(year + 1, prevRawOffset, prevDSTSavings, result);
366 } else {
367 result = tmp;
368 return TRUE;
369 }
370 }
371 return FALSE;
372 }
373
374 UBool
375 AnnualTimeZoneRule::getPreviousStart(UDate base,
376 int32_t prevRawOffset,
377 int32_t prevDSTSavings,
378 UBool inclusive,
379 UDate& result) const {
380 int32_t year, month, dom, dow, doy, mid;
381 Grego::timeToFields(base, year, month, dom, dow, doy, mid);
382 if (year > fEndYear) {
383 return getFinalStart(prevRawOffset, prevDSTSavings, result);
384 }
385 UDate tmp;
386 if (getStartInYear(year, prevRawOffset, prevDSTSavings, tmp)) {
387 if (tmp > base || (!inclusive && (tmp == base))) {
388 // Return the previous one
389 return getStartInYear(year - 1, prevRawOffset, prevDSTSavings, result);
390 } else {
391 result = tmp;
392 return TRUE;
393 }
394 }
395 return FALSE;
396 }
397
398 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(TimeArrayTimeZoneRule)
399
400 TimeArrayTimeZoneRule::TimeArrayTimeZoneRule(const UnicodeString& name,
401 int32_t rawOffset,
402 int32_t dstSavings,
403 const UDate* startTimes,
404 int32_t numStartTimes,
405 DateTimeRule::TimeRuleType timeRuleType)
406 : TimeZoneRule(name, rawOffset, dstSavings), fTimeRuleType(timeRuleType),
407 fStartTimes(NULL) {
408 UErrorCode status = U_ZERO_ERROR;
409 initStartTimes(startTimes, numStartTimes, status);
410 //TODO - status?
411 }
412
413
414 TimeArrayTimeZoneRule::TimeArrayTimeZoneRule(const TimeArrayTimeZoneRule& source)
415 : TimeZoneRule(source), fTimeRuleType(source.fTimeRuleType), fStartTimes(NULL) {
416 UErrorCode status = U_ZERO_ERROR;
417 initStartTimes(source.fStartTimes, source.fNumStartTimes, status);
418 //TODO - status?
419 }
420
421
422 TimeArrayTimeZoneRule::~TimeArrayTimeZoneRule() {
423 if (fStartTimes != NULL && fStartTimes != fLocalStartTimes) {
424 uprv_free(fStartTimes);
425 }
426 }
427
428 TimeArrayTimeZoneRule*
429 TimeArrayTimeZoneRule::clone(void) const {
430 return new TimeArrayTimeZoneRule(*this);
431 }
432
433
434 TimeArrayTimeZoneRule&
435 TimeArrayTimeZoneRule::operator=(const TimeArrayTimeZoneRule& right) {
436 if (this != &right) {
437 TimeZoneRule::operator=(right);
438 UErrorCode status = U_ZERO_ERROR;
439 initStartTimes(right.fStartTimes, right.fNumStartTimes, status);
440 //TODO - status?
441 fTimeRuleType = right.fTimeRuleType;
442 }
443 return *this;
444 }
445
446 UBool
447 TimeArrayTimeZoneRule::operator==(const TimeZoneRule& that) const {
448 if (this == &that) {
449 return TRUE;
450 }
451 if (typeid(*this) != typeid(that) || TimeZoneRule::operator==(that) == FALSE) {
452 return FALSE;
453 }
454 TimeArrayTimeZoneRule *tatzr = (TimeArrayTimeZoneRule*)&that;
455 if (fTimeRuleType != tatzr->fTimeRuleType ||
456 fNumStartTimes != tatzr->fNumStartTimes) {
457 return FALSE;
458 }
459 // Compare start times
460 UBool res = TRUE;
461 for (int32_t i = 0; i < fNumStartTimes; i++) {
462 if (fStartTimes[i] != tatzr->fStartTimes[i]) {
463 res = FALSE;
464 break;
465 }
466 }
467 return res;
468 }
469
470 UBool
471 TimeArrayTimeZoneRule::operator!=(const TimeZoneRule& that) const {
472 return !operator==(that);
473 }
474
475 DateTimeRule::TimeRuleType
476 TimeArrayTimeZoneRule::getTimeType(void) const {
477 return fTimeRuleType;
478 }
479
480 UBool
481 TimeArrayTimeZoneRule::getStartTimeAt(int32_t index, UDate& result) const {
482 if (index >= fNumStartTimes || index < 0) {
483 return FALSE;
484 }
485 result = fStartTimes[index];
486 return TRUE;
487 }
488
489 int32_t
490 TimeArrayTimeZoneRule::countStartTimes(void) const {
491 return fNumStartTimes;
492 }
493
494 UBool
495 TimeArrayTimeZoneRule::isEquivalentTo(const TimeZoneRule& other) const {
496 if (this == &other) {
497 return TRUE;
498 }
499 if (typeid(*this) != typeid(other) || TimeZoneRule::isEquivalentTo(other) == FALSE) {
500 return FALSE;
501 }
502 TimeArrayTimeZoneRule* that = (TimeArrayTimeZoneRule*)&other;
503 if (fTimeRuleType != that->fTimeRuleType ||
504 fNumStartTimes != that->fNumStartTimes) {
505 return FALSE;
506 }
507 // Compare start times
508 UBool res = TRUE;
509 for (int32_t i = 0; i < fNumStartTimes; i++) {
510 if (fStartTimes[i] != that->fStartTimes[i]) {
511 res = FALSE;
512 break;
513 }
514 }
515 return res;
516 }
517
518 UBool
519 TimeArrayTimeZoneRule::getFirstStart(int32_t prevRawOffset,
520 int32_t prevDSTSavings,
521 UDate& result) const {
522 if (fNumStartTimes <= 0 || fStartTimes == NULL) {
523 return FALSE;
524 }
525 result = getUTC(fStartTimes[0], prevRawOffset, prevDSTSavings);
526 return TRUE;
527 }
528
529 UBool
530 TimeArrayTimeZoneRule::getFinalStart(int32_t prevRawOffset,
531 int32_t prevDSTSavings,
532 UDate& result) const {
533 if (fNumStartTimes <= 0 || fStartTimes == NULL) {
534 return FALSE;
535 }
536 result = getUTC(fStartTimes[fNumStartTimes - 1], prevRawOffset, prevDSTSavings);
537 return TRUE;
538 }
539
540 UBool
541 TimeArrayTimeZoneRule::getNextStart(UDate base,
542 int32_t prevRawOffset,
543 int32_t prevDSTSavings,
544 UBool inclusive,
545 UDate& result) const {
546 int32_t i = fNumStartTimes - 1;
547 for (; i >= 0; i--) {
548 UDate time = getUTC(fStartTimes[i], prevRawOffset, prevDSTSavings);
549 if (time < base || (!inclusive && time == base)) {
550 break;
551 }
552 result = time;
553 }
554 if (i == fNumStartTimes - 1) {
555 return FALSE;
556 }
557 return TRUE;
558 }
559
560 UBool
561 TimeArrayTimeZoneRule::getPreviousStart(UDate base,
562 int32_t prevRawOffset,
563 int32_t prevDSTSavings,
564 UBool inclusive,
565 UDate& result) const {
566 int32_t i = fNumStartTimes - 1;
567 for (; i >= 0; i--) {
568 UDate time = getUTC(fStartTimes[i], prevRawOffset, prevDSTSavings);
569 if (time < base || (inclusive && time == base)) {
570 result = time;
571 return TRUE;
572 }
573 }
574 return FALSE;
575 }
576
577
578 // ---- private methods ------
579
580 UBool
581 TimeArrayTimeZoneRule::initStartTimes(const UDate source[], int32_t size, UErrorCode& status) {
582 // Free old array
583 if (fStartTimes != NULL && fStartTimes != fLocalStartTimes) {
584 uprv_free(fStartTimes);
585 }
586 // Allocate new one if needed
587 if (size > TIMEARRAY_STACK_BUFFER_SIZE) {
588 fStartTimes = (UDate*)uprv_malloc(sizeof(UDate)*size);
589 if (fStartTimes == NULL) {
590 status = U_MEMORY_ALLOCATION_ERROR;
591 fNumStartTimes = 0;
592 return FALSE;
593 }
594 } else {
595 fStartTimes = (UDate*)fLocalStartTimes;
596 }
597 uprv_memcpy(fStartTimes, source, sizeof(UDate)*size);
598 fNumStartTimes = size;
599 // Sort dates
600 uprv_sortArray(fStartTimes, fNumStartTimes, (int32_t)sizeof(UDate), compareDates, NULL, TRUE, &status);
601 if (U_FAILURE(status)) {
602 if (fStartTimes != NULL && fStartTimes != fLocalStartTimes) {
603 uprv_free(fStartTimes);
604 }
605 fNumStartTimes = 0;
606 return FALSE;
607 }
608 return TRUE;
609 }
610
611 UDate
612 TimeArrayTimeZoneRule::getUTC(UDate time, int32_t raw, int32_t dst) const {
613 if (fTimeRuleType != DateTimeRule::UTC_TIME) {
614 time -= raw;
615 }
616 if (fTimeRuleType == DateTimeRule::WALL_TIME) {
617 time -= dst;
618 }
619 return time;
620 }
621
622 U_NAMESPACE_END
623
624 #endif /* #if !UCONFIG_NO_FORMATTING */
625
626 //eof
627

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial