source/i18n/unicode/tzrule.h

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