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 829