icuSources/i18n/unicode/tzrule.h

   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