The Tor Browser / file comparison

comparison: intl/icu/source/i18n/unicode/tzrule.h

intl/icu/source/i18n/unicode/tzrule.h

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:010122848824
1 /*
2 *******************************************************************************
3 * Copyright (C) 2007-2008, International Business Machines Corporation and *
4 * others. All Rights Reserved. *
5 *******************************************************************************
6 */
7 #ifndef TZRULE_H
8 #define TZRULE_H
9
10 /**
11 * \file
12 * \brief C++ API: Time zone rule classes
13 */
14
15 #include "unicode/utypes.h"
16
17 #if !UCONFIG_NO_FORMATTING
18
19 #include "unicode/uobject.h"
20 #include "unicode/unistr.h"
21 #include "unicode/dtrule.h"
22
23 U_NAMESPACE_BEGIN
24
25 /**
26 * <code>TimeZoneRule</code> is a class representing a rule for time zone.
27 * <code>TimeZoneRule</code> has a set of time zone attributes, such as zone name,
28 * raw offset (UTC offset for standard time) and daylight saving time offset.
29 *
30 * @stable ICU 3.8
31 */
32 class U_I18N_API TimeZoneRule : public UObject {
33 public:
34 /**
35 * Destructor.
36 * @stable ICU 3.8
37 */
38 virtual ~TimeZoneRule();
39
40 /**
41 * Clone this TimeZoneRule object polymorphically. The caller owns the result and
42 * should delete it when done.
43 * @return A copy of the object.
44 * @stable ICU 3.8
45 */
46 virtual TimeZoneRule* clone(void) const = 0;
47
48 /**
49 * Return true if the given <code>TimeZoneRule</code> objects are semantically equal. Objects
50 * of different subclasses are considered unequal.
51 * @param that The object to be compared with.
52 * @return true if the given <code>TimeZoneRule</code> objects are semantically equal.
53 * @stable ICU 3.8
54 */
55 virtual UBool operator==(const TimeZoneRule& that) const;
56
57 /**
58 * Return true if the given <code>TimeZoneRule</code> objects are semantically unequal. Objects
59 * of different subclasses are considered unequal.
60 * @param that The object to be compared with.
61 * @return true if the given <code>TimeZoneRule</code> objects are semantically unequal.
62 * @stable ICU 3.8
63 */
64 virtual UBool operator!=(const TimeZoneRule& that) const;
65
66 /**
67 * Fills in "name" with the name of this time zone.
68 * @param name Receives the name of this time zone.
69 * @return A reference to "name"
70 * @stable ICU 3.8
71 */
72 UnicodeString& getName(UnicodeString& name) const;
73
74 /**
75 * Gets the standard time offset.
76 * @return The standard time offset from UTC in milliseconds.
77 * @stable ICU 3.8
78 */
79 int32_t getRawOffset(void) const;
80
81 /**
82 * Gets the amount of daylight saving delta time from the standard time.
83 * @return The amount of daylight saving offset used by this rule
84 * in milliseconds.
85 * @stable ICU 3.8
86 */
87 int32_t getDSTSavings(void) const;
88
89 /**
90 * Returns if this rule represents the same rule and offsets as another.
91 * When two <code>TimeZoneRule</code> objects differ only its names, this method
92 * returns true.
93 * @param other The <code>TimeZoneRule</code> object to be compared with.
94 * @return true if the other <code>TimeZoneRule</code> is the same as this one.
95 * @stable ICU 3.8
96 */
97 virtual UBool isEquivalentTo(const TimeZoneRule& other) const;
98
99 /**
100 * Gets the very first time when this rule takes effect.
101 * @param prevRawOffset The standard time offset from UTC before this rule
102 * takes effect in milliseconds.
103 * @param prevDSTSavings The amount of daylight saving offset from the
104 * standard time.
105 * @param result Receives the very first time when this rule takes effect.
106 * @return true if the start time is available. When false is returned, output parameter
107 * "result" is unchanged.
108 * @stable ICU 3.8
109 */
110 virtual UBool getFirstStart(int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const = 0;
111
112 /**
113 * Gets the final time when this rule takes effect.
114 * @param prevRawOffset The standard time offset from UTC before this rule
115 * takes effect in milliseconds.
116 * @param prevDSTSavings The amount of daylight saving offset from the
117 * standard time.
118 * @param result Receives the final time when this rule takes effect.
119 * @return true if the start time is available. When false is returned, output parameter
120 * "result" is unchanged.
121 * @stable ICU 3.8
122 */
123 virtual UBool getFinalStart(int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const = 0;
124
125 /**
126 * Gets the first time when this rule takes effect after the specified time.
127 * @param base The first start time after this base time will be returned.
128 * @param prevRawOffset The standard time offset from UTC before this rule
129 * takes effect in milliseconds.
130 * @param prevDSTSavings The amount of daylight saving offset from the
131 * standard time.
132 * @param inclusive Whether the base time is inclusive or not.
133 * @param result Receives The first time when this rule takes effect after
134 * the specified base time.
135 * @return true if the start time is available. When false is returned, output parameter
136 * "result" is unchanged.
137 * @stable ICU 3.8
138 */
139 virtual UBool getNextStart(UDate base, int32_t prevRawOffset, int32_t prevDSTSavings,
140 UBool inclusive, UDate& result) const = 0;
141
142 /**
143 * Gets the most recent time when this rule takes effect before the specified time.
144 * @param base The most recent time before this base time will be returned.
145 * @param prevRawOffset The standard time offset from UTC before this rule
146 * takes effect in milliseconds.
147 * @param prevDSTSavings The amount of daylight saving offset from the
148 * standard time.
149 * @param inclusive Whether the base time is inclusive or not.
150 * @param result Receives The most recent time when this rule takes effect before
151 * the specified base time.
152 * @return true if the start time is available. When false is returned, output parameter
153 * "result" is unchanged.
154 * @stable ICU 3.8
155 */
156 virtual UBool getPreviousStart(UDate base, int32_t prevRawOffset, int32_t prevDSTSavings,
157 UBool inclusive, UDate& result) const = 0;
158
159 protected:
160
161 /**
162 * Constructs a <code>TimeZoneRule</code> with the name, the GMT offset of its
163 * standard time and the amount of daylight saving offset adjustment.
164 * @param name The time zone name.
165 * @param rawOffset The UTC offset of its standard time in milliseconds.
166 * @param dstSavings The amount of daylight saving offset adjustment in milliseconds.
167 * If this ia a rule for standard time, the value of this argument is 0.
168 * @stable ICU 3.8
169 */
170 TimeZoneRule(const UnicodeString& name, int32_t rawOffset, int32_t dstSavings);
171
172 /**
173 * Copy constructor.
174 * @param source The TimeZoneRule object to be copied.
175 * @stable ICU 3.8
176 */
177 TimeZoneRule(const TimeZoneRule& source);
178
179 /**
180 * Assignment operator.
181 * @param right The object to be copied.
182 * @stable ICU 3.8
183 */
184 TimeZoneRule& operator=(const TimeZoneRule& right);
185
186 private:
187 UnicodeString fName; // time name
188 int32_t fRawOffset; // UTC offset of the standard time in milliseconds
189 int32_t fDSTSavings; // DST saving amount in milliseconds
190 };
191
192 /**
193 * <code>InitialTimeZoneRule</code> represents a time zone rule
194 * representing a time zone effective from the beginning and
195 * has no actual start times.
196 * @stable ICU 3.8
197 */
198 class U_I18N_API InitialTimeZoneRule : public TimeZoneRule {
199 public:
200 /**
201 * Constructs an <code>InitialTimeZoneRule</code> with the name, the GMT offset of its
202 * standard time and the amount of daylight saving offset adjustment.
203 * @param name The time zone name.
204 * @param rawOffset The UTC offset of its standard time in milliseconds.
205 * @param dstSavings The amount of daylight saving offset adjustment in milliseconds.
206 * If this ia a rule for standard time, the value of this argument is 0.
207 * @stable ICU 3.8
208 */
209 InitialTimeZoneRule(const UnicodeString& name, int32_t rawOffset, int32_t dstSavings);
210
211 /**
212 * Copy constructor.
213 * @param source The InitialTimeZoneRule object to be copied.
214 * @stable ICU 3.8
215 */
216 InitialTimeZoneRule(const InitialTimeZoneRule& source);
217
218 /**
219 * Destructor.
220 * @stable ICU 3.8
221 */
222 virtual ~InitialTimeZoneRule();
223
224 /**
225 * Clone this InitialTimeZoneRule object polymorphically. The caller owns the result and
226 * should delete it when done.
227 * @return A copy of the object.
228 * @stable ICU 3.8
229 */
230 virtual InitialTimeZoneRule* clone(void) const;
231
232 /**
233 * Assignment operator.
234 * @param right The object to be copied.
235 * @stable ICU 3.8
236 */
237 InitialTimeZoneRule& operator=(const InitialTimeZoneRule& right);
238
239 /**
240 * Return true if the given <code>TimeZoneRule</code> objects are semantically equal. Objects
241 * of different subclasses are considered unequal.
242 * @param that The object to be compared with.
243 * @return true if the given <code>TimeZoneRule</code> objects are semantically equal.
244 * @stable ICU 3.8
245 */
246 virtual UBool operator==(const TimeZoneRule& that) const;
247
248 /**
249 * Return true if the given <code>TimeZoneRule</code> objects are semantically unequal. Objects
250 * of different subclasses are considered unequal.
251 * @param that The object to be compared with.
252 * @return true if the given <code>TimeZoneRule</code> objects are semantically unequal.
253 * @stable ICU 3.8
254 */
255 virtual UBool operator!=(const TimeZoneRule& that) const;
256
257 /**
258 * Gets the time when this rule takes effect in the given year.
259 * @param year The Gregorian year, with 0 == 1 BCE, -1 == 2 BCE, etc.
260 * @param prevRawOffset The standard time offset from UTC before this rule
261 * takes effect in milliseconds.
262 * @param prevDSTSavings The amount of daylight saving offset from the
263 * standard time.
264 * @param result Receives the start time in the year.
265 * @return true if this rule takes effect in the year and the result is set to
266 * "result".
267 * @stable ICU 3.8
268 */
269 UBool getStartInYear(int32_t year, int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const;
270
271 /**
272 * Returns if this rule represents the same rule and offsets as another.
273 * When two <code>TimeZoneRule</code> objects differ only its names, this method
274 * returns true.
275 * @param that The <code>TimeZoneRule</code> object to be compared with.
276 * @return true if the other <code>TimeZoneRule</code> is equivalent to this one.
277 * @stable ICU 3.8
278 */
279 virtual UBool isEquivalentTo(const TimeZoneRule& that) const;
280
281 /**
282 * Gets the very first time when this rule takes effect.
283 * @param prevRawOffset The standard time offset from UTC before this rule
284 * takes effect in milliseconds.
285 * @param prevDSTSavings The amount of daylight saving offset from the
286 * standard time.
287 * @param result Receives the very first time when this rule takes effect.
288 * @return true if the start time is available. When false is returned, output parameter
289 * "result" is unchanged.
290 * @stable ICU 3.8
291 */
292 virtual UBool getFirstStart(int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const;
293
294 /**
295 * Gets the final time when this rule takes effect.
296 * @param prevRawOffset The standard time offset from UTC before this rule
297 * takes effect in milliseconds.
298 * @param prevDSTSavings The amount of daylight saving offset from the
299 * standard time.
300 * @param result Receives the final time when this rule takes effect.
301 * @return true if the start time is available. When false is returned, output parameter
302 * "result" is unchanged.
303 * @stable ICU 3.8
304 */
305 virtual UBool getFinalStart(int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const;
306
307 /**
308 * Gets the first time when this rule takes effect after the specified time.
309 * @param base The first start time after this base time will be returned.
310 * @param prevRawOffset The standard time offset from UTC before this rule
311 * takes effect in milliseconds.
312 * @param prevDSTSavings The amount of daylight saving offset from the
313 * standard time.
314 * @param inclusive Whether the base time is inclusive or not.
315 * @param result Receives The first time when this rule takes effect after
316 * the specified base time.
317 * @return true if the start time is available. When false is returned, output parameter
318 * "result" is unchanged.
319 * @stable ICU 3.8
320 */
321 virtual UBool getNextStart(UDate base, int32_t prevRawOffset, int32_t prevDSTSavings,
322 UBool inclusive, UDate& result) const;
323
324 /**
325 * Gets the most recent time when this rule takes effect before the specified time.
326 * @param base The most recent time before this base time will be returned.
327 * @param prevRawOffset The standard time offset from UTC before this rule
328 * takes effect in milliseconds.
329 * @param prevDSTSavings The amount of daylight saving offset from the
330 * standard time.
331 * @param inclusive Whether the base time is inclusive or not.
332 * @param result Receives The most recent time when this rule takes effect before
333 * the specified base time.
334 * @return true if the start time is available. When false is returned, output parameter
335 * "result" is unchanged.
336 * @stable ICU 3.8
337 */
338 virtual UBool getPreviousStart(UDate base, int32_t prevRawOffset, int32_t prevDSTSavings,
339 UBool inclusive, UDate& result) const;
340
341 public:
342 /**
343 * Return the class ID for this class. This is useful only for comparing to
344 * a return value from getDynamicClassID(). For example:
345 * <pre>
346 * . Base* polymorphic_pointer = createPolymorphicObject();
347 * . if (polymorphic_pointer->getDynamicClassID() ==
348 * . erived::getStaticClassID()) ...
349 * </pre>
350 * @return The class ID for all objects of this class.
351 * @stable ICU 3.8
352 */
353 static UClassID U_EXPORT2 getStaticClassID(void);
354
355 /**
356 * Returns a unique class ID POLYMORPHICALLY. Pure virtual override. This
357 * method is to implement a simple version of RTTI, since not all C++
358 * compilers support genuine RTTI. Polymorphic operator==() and clone()
359 * methods call this method.
360 *
361 * @return The class ID for this object. All objects of a
362 * given class have the same class ID. Objects of
363 * other classes have different class IDs.
364 * @stable ICU 3.8
365 */
366 virtual UClassID getDynamicClassID(void) const;
367 };
368
369 /**
370 * <code>AnnualTimeZoneRule</code> is a class used for representing a time zone
371 * rule which takes effect annually. The calenday system used for the rule is
372 * is based on Gregorian calendar
373 *
374 * @stable ICU 3.8
375 */
376 class U_I18N_API AnnualTimeZoneRule : public TimeZoneRule {
377 public:
378 /**
379 * The constant representing the maximum year used for designating
380 * a rule is permanent.
381 */
382 static const int32_t MAX_YEAR;
383
384 /**
385 * Constructs a <code>AnnualTimeZoneRule</code> with the name, the GMT offset of its
386 * standard time, the amount of daylight saving offset adjustment, the annual start
387 * time rule and the start/until years. The input DateTimeRule is copied by this
388 * constructor, so the caller remains responsible for deleting the object.
389 * @param name The time zone name.
390 * @param rawOffset The GMT offset of its standard time in milliseconds.
391 * @param dstSavings The amount of daylight saving offset adjustment in
392 * milliseconds. If this ia a rule for standard time,
393 * the value of this argument is 0.
394 * @param dateTimeRule The start date/time rule repeated annually.
395 * @param startYear The first year when this rule takes effect.
396 * @param endYear The last year when this rule takes effect. If this
397 * rule is effective forever in future, specify MAX_YEAR.
398 * @stable ICU 3.8
399 */
400 AnnualTimeZoneRule(const UnicodeString& name, int32_t rawOffset, int32_t dstSavings,
401 const DateTimeRule& dateTimeRule, int32_t startYear, int32_t endYear);
402
403 /**
404 * Constructs a <code>AnnualTimeZoneRule</code> with the name, the GMT offset of its
405 * standard time, the amount of daylight saving offset adjustment, the annual start
406 * time rule and the start/until years. The input DateTimeRule object is adopted
407 * by this object, therefore, the caller must not delete the object.
408 * @param name The time zone name.
409 * @param rawOffset The GMT offset of its standard time in milliseconds.
410 * @param dstSavings The amount of daylight saving offset adjustment in
411 * milliseconds. If this ia a rule for standard time,
412 * the value of this argument is 0.
413 * @param dateTimeRule The start date/time rule repeated annually.
414 * @param startYear The first year when this rule takes effect.
415 * @param endYear The last year when this rule takes effect. If this
416 * rule is effective forever in future, specify MAX_YEAR.
417 * @stable ICU 3.8
418 */
419 AnnualTimeZoneRule(const UnicodeString& name, int32_t rawOffset, int32_t dstSavings,
420 DateTimeRule* dateTimeRule, int32_t startYear, int32_t endYear);
421
422 /**
423 * Copy constructor.
424 * @param source The AnnualTimeZoneRule object to be copied.
425 * @stable ICU 3.8
426 */
427 AnnualTimeZoneRule(const AnnualTimeZoneRule& source);
428
429 /**
430 * Destructor.
431 * @stable ICU 3.8
432 */
433 virtual ~AnnualTimeZoneRule();
434
435 /**
436 * Clone this AnnualTimeZoneRule object polymorphically. The caller owns the result and
437 * should delete it when done.
438 * @return A copy of the object.
439 * @stable ICU 3.8
440 */
441 virtual AnnualTimeZoneRule* clone(void) const;
442
443 /**
444 * Assignment operator.
445 * @param right The object to be copied.
446 * @stable ICU 3.8
447 */
448 AnnualTimeZoneRule& operator=(const AnnualTimeZoneRule& right);
449
450 /**
451 * Return true if the given <code>TimeZoneRule</code> objects are semantically equal. Objects
452 * of different subclasses are considered unequal.
453 * @param that The object to be compared with.
454 * @return true if the given <code>TimeZoneRule</code> objects are semantically equal.
455 * @stable ICU 3.8
456 */
457 virtual UBool operator==(const TimeZoneRule& that) const;
458
459 /**
460 * Return true if the given <code>TimeZoneRule</code> objects are semantically unequal. Objects
461 * of different subclasses are considered unequal.
462 * @param that The object to be compared with.
463 * @return true if the given <code>TimeZoneRule</code> objects are semantically unequal.
464 * @stable ICU 3.8
465 */
466 virtual UBool operator!=(const TimeZoneRule& that) const;
467
468 /**
469 * Gets the start date/time rule used by this rule.
470 * @return The <code>AnnualDateTimeRule</code> which represents the start date/time
471 * rule used by this time zone rule.
472 * @stable ICU 3.8
473 */
474 const DateTimeRule* getRule(void) const;
475
476 /**
477 * Gets the first year when this rule takes effect.
478 * @return The start year of this rule. The year is in Gregorian calendar
479 * with 0 == 1 BCE, -1 == 2 BCE, etc.
480 * @stable ICU 3.8
481 */
482 int32_t getStartYear(void) const;
483
484 /**
485 * Gets the end year when this rule takes effect.
486 * @return The end year of this rule (inclusive). The year is in Gregorian calendar
487 * with 0 == 1 BCE, -1 == 2 BCE, etc.
488 * @stable ICU 3.8
489 */
490 int32_t getEndYear(void) const;
491
492 /**
493 * Gets the time when this rule takes effect in the given year.
494 * @param year The Gregorian year, with 0 == 1 BCE, -1 == 2 BCE, etc.
495 * @param prevRawOffset The standard time offset from UTC before this rule
496 * takes effect in milliseconds.
497 * @param prevDSTSavings The amount of daylight saving offset from the
498 * standard time.
499 * @param result Receives the start time in the year.
500 * @return true if this rule takes effect in the year and the result is set to
501 * "result".
502 * @stable ICU 3.8
503 */
504 UBool getStartInYear(int32_t year, int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const;
505
506 /**
507 * Returns if this rule represents the same rule and offsets as another.
508 * When two <code>TimeZoneRule</code> objects differ only its names, this method
509 * returns true.
510 * @param that The <code>TimeZoneRule</code> object to be compared with.
511 * @return true if the other <code>TimeZoneRule</code> is equivalent to this one.
512 * @stable ICU 3.8
513 */
514 virtual UBool isEquivalentTo(const TimeZoneRule& that) const;
515
516 /**
517 * Gets the very first time when this rule takes effect.
518 * @param prevRawOffset The standard time offset from UTC before this rule
519 * takes effect in milliseconds.
520 * @param prevDSTSavings The amount of daylight saving offset from the
521 * standard time.
522 * @param result Receives the very first time when this rule takes effect.
523 * @return true if the start time is available. When false is returned, output parameter
524 * "result" is unchanged.
525 * @stable ICU 3.8
526 */
527 virtual UBool getFirstStart(int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const;
528
529 /**
530 * Gets the final time when this rule takes effect.
531 * @param prevRawOffset The standard time offset from UTC before this rule
532 * takes effect in milliseconds.
533 * @param prevDSTSavings The amount of daylight saving offset from the
534 * standard time.
535 * @param result Receives the final time when this rule takes effect.
536 * @return true if the start time is available. When false is returned, output parameter
537 * "result" is unchanged.
538 * @stable ICU 3.8
539 */
540 virtual UBool getFinalStart(int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const;
541
542 /**
543 * Gets the first time when this rule takes effect after the specified time.
544 * @param base The first start time after this base time will be returned.
545 * @param prevRawOffset The standard time offset from UTC before this rule
546 * takes effect in milliseconds.
547 * @param prevDSTSavings The amount of daylight saving offset from the
548 * standard time.
549 * @param inclusive Whether the base time is inclusive or not.
550 * @param result Receives The first time when this rule takes effect after
551 * the specified base time.
552 * @return true if the start time is available. When false is returned, output parameter
553 * "result" is unchanged.
554 * @stable ICU 3.8
555 */
556 virtual UBool getNextStart(UDate base, int32_t prevRawOffset, int32_t prevDSTSavings,
557 UBool inclusive, UDate& result) const;
558
559 /**
560 * Gets the most recent time when this rule takes effect before the specified time.
561 * @param base The most recent time before this base time will be returned.
562 * @param prevRawOffset The standard time offset from UTC before this rule
563 * takes effect in milliseconds.
564 * @param prevDSTSavings The amount of daylight saving offset from the
565 * standard time.
566 * @param inclusive Whether the base time is inclusive or not.
567 * @param result Receives The most recent time when this rule takes effect before
568 * the specified base time.
569 * @return true if the start time is available. When false is returned, output parameter
570 * "result" is unchanged.
571 * @stable ICU 3.8
572 */
573 virtual UBool getPreviousStart(UDate base, int32_t prevRawOffset, int32_t prevDSTSavings,
574 UBool inclusive, UDate& result) const;
575
576
577 private:
578 DateTimeRule* fDateTimeRule;
579 int32_t fStartYear;
580 int32_t fEndYear;
581
582 public:
583 /**
584 * Return the class ID for this class. This is useful only for comparing to
585 * a return value from getDynamicClassID(). For example:
586 * <pre>
587 * . Base* polymorphic_pointer = createPolymorphicObject();
588 * . if (polymorphic_pointer->getDynamicClassID() ==
589 * . erived::getStaticClassID()) ...
590 * </pre>
591 * @return The class ID for all objects of this class.
592 * @stable ICU 3.8
593 */
594 static UClassID U_EXPORT2 getStaticClassID(void);
595
596 /**
597 * Returns a unique class ID POLYMORPHICALLY. Pure virtual override. This
598 * method is to implement a simple version of RTTI, since not all C++
599 * compilers support genuine RTTI. Polymorphic operator==() and clone()
600 * methods call this method.
601 *
602 * @return The class ID for this object. All objects of a
603 * given class have the same class ID. Objects of
604 * other classes have different class IDs.
605 * @stable ICU 3.8
606 */
607 virtual UClassID getDynamicClassID(void) const;
608 };
609
610 /**
611 * <code>TimeArrayTimeZoneRule</code> represents a time zone rule whose start times are
612 * defined by an array of milliseconds since the standard base time.
613 *
614 * @stable ICU 3.8
615 */
616 class U_I18N_API TimeArrayTimeZoneRule : public TimeZoneRule {
617 public:
618 /**
619 * Constructs a <code>TimeArrayTimeZoneRule</code> with the name, the GMT offset of its
620 * standard time, the amount of daylight saving offset adjustment and
621 * the array of times when this rule takes effect.
622 * @param name The time zone name.
623 * @param rawOffset The UTC offset of its standard time in milliseconds.
624 * @param dstSavings The amount of daylight saving offset adjustment in
625 * milliseconds. If this ia a rule for standard time,
626 * the value of this argument is 0.
627 * @param startTimes The array start times in milliseconds since the base time
628 * (January 1, 1970, 00:00:00).
629 * @param numStartTimes The number of elements in the parameter "startTimes"
630 * @param timeRuleType The time type of the start times, which is one of
631 * <code>DataTimeRule::WALL_TIME</code>, <code>STANDARD_TIME</code>
632 * and <code>UTC_TIME</code>.
633 * @stable ICU 3.8
634 */
635 TimeArrayTimeZoneRule(const UnicodeString& name, int32_t rawOffset, int32_t dstSavings,
636 const UDate* startTimes, int32_t numStartTimes, DateTimeRule::TimeRuleType timeRuleType);
637
638 /**
639 * Copy constructor.
640 * @param source The TimeArrayTimeZoneRule object to be copied.
641 * @stable ICU 3.8
642 */
643 TimeArrayTimeZoneRule(const TimeArrayTimeZoneRule& source);
644
645 /**
646 * Destructor.
647 * @stable ICU 3.8
648 */
649 virtual ~TimeArrayTimeZoneRule();
650
651 /**
652 * Clone this TimeArrayTimeZoneRule object polymorphically. The caller owns the result and
653 * should delete it when done.
654 * @return A copy of the object.
655 * @stable ICU 3.8
656 */
657 virtual TimeArrayTimeZoneRule* clone(void) const;
658
659 /**
660 * Assignment operator.
661 * @param right The object to be copied.
662 * @stable ICU 3.8
663 */
664 TimeArrayTimeZoneRule& operator=(const TimeArrayTimeZoneRule& right);
665
666 /**
667 * Return true if the given <code>TimeZoneRule</code> objects are semantically equal. Objects
668 * of different subclasses are considered unequal.
669 * @param that The object to be compared with.
670 * @return true if the given <code>TimeZoneRule</code> objects are semantically equal.
671 * @stable ICU 3.8
672 */
673 virtual UBool operator==(const TimeZoneRule& that) const;
674
675 /**
676 * Return true if the given <code>TimeZoneRule</code> objects are semantically unequal. Objects
677 * of different subclasses are considered unequal.
678 * @param that The object to be compared with.
679 * @return true if the given <code>TimeZoneRule</code> objects are semantically unequal.
680 * @stable ICU 3.8
681 */
682 virtual UBool operator!=(const TimeZoneRule& that) const;
683
684 /**
685 * Gets the time type of the start times used by this rule. The return value
686 * is either <code>DateTimeRule::WALL_TIME</code> or <code>STANDARD_TIME</code>
687 * or <code>UTC_TIME</code>.
688 *
689 * @return The time type used of the start times used by this rule.
690 * @stable ICU 3.8
691 */
692 DateTimeRule::TimeRuleType getTimeType(void) const;
693
694 /**
695 * Gets a start time at the index stored in this rule.
696 * @param index The index of start times
697 * @param result Receives the start time at the index
698 * @return true if the index is within the valid range and
699 * and the result is set. When false, the output
700 * parameger "result" is unchanged.
701 * @stable ICU 3.8
702 */
703 UBool getStartTimeAt(int32_t index, UDate& result) const;
704
705 /**
706 * Returns the number of start times stored in this rule
707 * @return The number of start times.
708 * @stable ICU 3.8
709 */
710 int32_t countStartTimes(void) const;
711
712 /**
713 * Returns if this rule represents the same rule and offsets as another.
714 * When two <code>TimeZoneRule</code> objects differ only its names, this method
715 * returns true.
716 * @param that The <code>TimeZoneRule</code> object to be compared with.
717 * @return true if the other <code>TimeZoneRule</code> is equivalent to this one.
718 * @stable ICU 3.8
719 */
720 virtual UBool isEquivalentTo(const TimeZoneRule& that) const;
721
722 /**
723 * Gets the very first time when this rule takes effect.
724 * @param prevRawOffset The standard time offset from UTC before this rule
725 * takes effect in milliseconds.
726 * @param prevDSTSavings The amount of daylight saving offset from the
727 * standard time.
728 * @param result Receives the very first time when this rule takes effect.
729 * @return true if the start time is available. When false is returned, output parameter
730 * "result" is unchanged.
731 * @stable ICU 3.8
732 */
733 virtual UBool getFirstStart(int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const;
734
735 /**
736 * Gets the final time when this rule takes effect.
737 * @param prevRawOffset The standard time offset from UTC before this rule
738 * takes effect in milliseconds.
739 * @param prevDSTSavings The amount of daylight saving offset from the
740 * standard time.
741 * @param result Receives the final time when this rule takes effect.
742 * @return true if the start time is available. When false is returned, output parameter
743 * "result" is unchanged.
744 * @stable ICU 3.8
745 */
746 virtual UBool getFinalStart(int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const;
747
748 /**
749 * Gets the first time when this rule takes effect after the specified time.
750 * @param base The first start time after this base time will be returned.
751 * @param prevRawOffset The standard time offset from UTC before this rule
752 * takes effect in milliseconds.
753 * @param prevDSTSavings The amount of daylight saving offset from the
754 * standard time.
755 * @param inclusive Whether the base time is inclusive or not.
756 * @param result Receives The first time when this rule takes effect after
757 * the specified base time.
758 * @return true if the start time is available. When false is returned, output parameter
759 * "result" is unchanged.
760 * @stable ICU 3.8
761 */
762 virtual UBool getNextStart(UDate base, int32_t prevRawOffset, int32_t prevDSTSavings,
763 UBool inclusive, UDate& result) const;
764
765 /**
766 * Gets the most recent time when this rule takes effect before the specified time.
767 * @param base The most recent time before this base time will be returned.
768 * @param prevRawOffset The standard time offset from UTC before this rule
769 * takes effect in milliseconds.
770 * @param prevDSTSavings The amount of daylight saving offset from the
771 * standard time.
772 * @param inclusive Whether the base time is inclusive or not.
773 * @param result Receives The most recent time when this rule takes effect before
774 * the specified base time.
775 * @return true if the start time is available. When false is returned, output parameter
776 * "result" is unchanged.
777 * @stable ICU 3.8
778 */
779 virtual UBool getPreviousStart(UDate base, int32_t prevRawOffset, int32_t prevDSTSavings,
780 UBool inclusive, UDate& result) const;
781
782
783 private:
784 enum { TIMEARRAY_STACK_BUFFER_SIZE = 32 };
785 UBool initStartTimes(const UDate source[], int32_t size, UErrorCode& ec);
786 UDate getUTC(UDate time, int32_t raw, int32_t dst) const;
787
788 DateTimeRule::TimeRuleType fTimeRuleType;
789 int32_t fNumStartTimes;
790 UDate* fStartTimes;
791 UDate fLocalStartTimes[TIMEARRAY_STACK_BUFFER_SIZE];
792
793 public:
794 /**
795 * Return the class ID for this class. This is useful only for comparing to
796 * a return value from getDynamicClassID(). For example:
797 * <pre>
798 * . Base* polymorphic_pointer = createPolymorphicObject();
799 * . if (polymorphic_pointer->getDynamicClassID() ==
800 * . erived::getStaticClassID()) ...
801 * </pre>
802 * @return The class ID for all objects of this class.
803 * @stable ICU 3.8
804 */
805 static UClassID U_EXPORT2 getStaticClassID(void);
806
807 /**
808 * Returns a unique class ID POLYMORPHICALLY. Pure virtual override. This
809 * method is to implement a simple version of RTTI, since not all C++
810 * compilers support genuine RTTI. Polymorphic operator==() and clone()
811 * methods call this method.
812 *
813 * @return The class ID for this object. All objects of a
814 * given class have the same class ID. Objects of
815 * other classes have different class IDs.
816 * @stable ICU 3.8
817 */
818 virtual UClassID getDynamicClassID(void) const;
819 };
820
821
822 U_NAMESPACE_END
823
824 #endif /* #if !UCONFIG_NO_FORMATTING */
825
826 #endif // TZRULE_H
827
828 //eof

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial