Mercurial > repos > rliterman > csp2

comparison CSP2/CSP2_env/env-d9b9114564458d9d-741b3de822f2aaca6c6caa4325c4afce/include/unicode/tzrule.h @ 69:33d812a61356

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