• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2 *******************************************************************************
3 * Copyright (C) 2007, 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  * @draft ICU 3.8
31  */
32 class U_I18N_API TimeZoneRule : public UObject {
33 public:
34     /**
35      * Destructor.
36      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft ICU 3.8
176      */
177     TimeZoneRule(const TimeZoneRule& source);
178 
179     /**
180      * Assignment operator.
181      * @param right The object to be copied.
182      * @draft 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  * @draft 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      * @draft 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      * @draft ICU 3.8
215      */
216     InitialTimeZoneRule(const InitialTimeZoneRule& source);
217 
218     /**
219      * Destructor.
220      * @draft 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      * @draft ICU 3.8
229      */
230     virtual InitialTimeZoneRule* clone(void) const;
231 
232     /**
233      * Assignment operator.
234      * @param right The object to be copied.
235      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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  * @draft 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      * @draft 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      * @draft 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      * @draft ICU 3.8
426      */
427     AnnualTimeZoneRule(const AnnualTimeZoneRule& source);
428 
429     /**
430      * Destructor.
431      * @draft 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      * @draft ICU 3.8
440      */
441     virtual AnnualTimeZoneRule* clone(void) const;
442 
443     /**
444      * Assignment operator.
445      * @param right The object to be copied.
446      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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  * @draft 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>UNIVERSAL_TIME</code>.
633      * @draft 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      * @draft ICU 3.8
642      */
643     TimeArrayTimeZoneRule(const TimeArrayTimeZoneRule& source);
644 
645     /**
646      * Destructor.
647      * @draft 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      * @draft ICU 3.8
656      */
657     virtual TimeArrayTimeZoneRule* clone(void) const;
658 
659     /**
660      * Assignment operator.
661      * @param right The object to be copied.
662      * @draft 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      * @draft 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      * @draft 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>UNIVERSAL_TIME</code>.
688      *
689      * @return The time type used of the start times used by this rule.
690      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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      * @draft 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
829