| OLD | NEW |
|---|
| (Empty) |
| 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 nam
e, | |
| 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 resul
t 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 semantical
ly 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 semantic
ally 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 semantical
ly 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 semantic
ally 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 me
thod | |
| 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 ru
le | |
| 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 take
s effect. | |
| 106 * @return true if the start time is available. When false is returned, ou
tput parameter | |
| 107 * "result" is unchanged. | |
| 108 * @stable ICU 3.8 | |
| 109 */ | |
| 110 virtual UBool getFirstStart(int32_t prevRawOffset, int32_t prevDSTSavings, U
Date& 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 ru
le | |
| 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 eff
ect. | |
| 119 * @return true if the start time is available. When false is returned, ou
tput parameter | |
| 120 * "result" is unchanged. | |
| 121 * @stable ICU 3.8 | |
| 122 */ | |
| 123 virtual UBool getFinalStart(int32_t prevRawOffset, int32_t prevDSTSavings, U
Date& 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 b
e returned. | |
| 128 * @param prevRawOffset The standard time offset from UTC before this ru
le | |
| 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 eff
ect after | |
| 134 * the specified base time. | |
| 135 * @return true if the start time is available. When false is returned, ou
tput parameter | |
| 136 * "result" is unchanged. | |
| 137 * @stable ICU 3.8 | |
| 138 */ | |
| 139 virtual UBool getNextStart(UDate base, int32_t prevRawOffset, int32_t prevDS
TSavings, | |
| 140 UBool inclusive, UDate& result) const = 0; | |
| 141 | |
| 142 /** | |
| 143 * Gets the most recent time when this rule takes effect before the specifie
d 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 ru
le | |
| 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 tak
es effect before | |
| 151 * the specified base time. | |
| 152 * @return true if the start time is available. When false is returned, ou
tput parameter | |
| 153 * "result" is unchanged. | |
| 154 * @stable ICU 3.8 | |
| 155 */ | |
| 156 virtual UBool getPreviousStart(UDate base, int32_t prevRawOffset, int32_t pr
evDSTSavings, | |
| 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 i
ts | |
| 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 m
illiseconds. | |
| 167 * If this ia a rule for standard time, the value of th
is argument is 0. | |
| 168 * @stable ICU 3.8 | |
| 169 */ | |
| 170 TimeZoneRule(const UnicodeString& name, int32_t rawOffset, int32_t dstSaving
s); | |
| 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 off
set 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 m
illiseconds. | |
| 206 * If this ia a rule for standard time, the value of th
is argument is 0. | |
| 207 * @stable ICU 3.8 | |
| 208 */ | |
| 209 InitialTimeZoneRule(const UnicodeString& name, int32_t rawOffset, int32_t ds
tSavings); | |
| 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 th
e 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 semantical
ly 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 semantic
ally 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 semantical
ly 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 semantic
ally 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 ru
le | |
| 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 prevDSTSav
ings, 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 me
thod | |
| 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 thi
s 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 ru
le | |
| 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 take
s effect. | |
| 288 * @return true if the start time is available. When false is returned, ou
tput parameter | |
| 289 * "result" is unchanged. | |
| 290 * @stable ICU 3.8 | |
| 291 */ | |
| 292 virtual UBool getFirstStart(int32_t prevRawOffset, int32_t prevDSTSavings, U
Date& 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 ru
le | |
| 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 eff
ect. | |
| 301 * @return true if the start time is available. When false is returned, ou
tput parameter | |
| 302 * "result" is unchanged. | |
| 303 * @stable ICU 3.8 | |
| 304 */ | |
| 305 virtual UBool getFinalStart(int32_t prevRawOffset, int32_t prevDSTSavings, U
Date& 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 b
e returned. | |
| 310 * @param prevRawOffset The standard time offset from UTC before this ru
le | |
| 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 eff
ect after | |
| 316 * the specified base time. | |
| 317 * @return true if the start time is available. When false is returned, ou
tput parameter | |
| 318 * "result" is unchanged. | |
| 319 * @stable ICU 3.8 | |
| 320 */ | |
| 321 virtual UBool getNextStart(UDate base, int32_t prevRawOffset, int32_t prevDS
TSavings, | |
| 322 UBool inclusive, UDate& result) const; | |
| 323 | |
| 324 /** | |
| 325 * Gets the most recent time when this rule takes effect before the specifie
d 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 ru
le | |
| 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 tak
es effect before | |
| 333 * the specified base time. | |
| 334 * @return true if the start time is available. When false is returned, ou
tput parameter | |
| 335 * "result" is unchanged. | |
| 336 * @stable ICU 3.8 | |
| 337 */ | |
| 338 virtual UBool getPreviousStart(UDate base, int32_t prevRawOffset, int32_t pr
evDSTSavings, | |
| 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 offse
t of its | |
| 386 * standard time, the amount of daylight saving offset adjustment, the annua
l 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_YEA
R. | |
| 398 * @stable ICU 3.8 | |
| 399 */ | |
| 400 AnnualTimeZoneRule(const UnicodeString& name, int32_t rawOffset, int32_t dst
Savings, | |
| 401 const DateTimeRule& dateTimeRule, int32_t startYear, int32_t endYear
); | |
| 402 | |
| 403 /** | |
| 404 * Constructs a <code>AnnualTimeZoneRule</code> with the name, the GMT offse
t of its | |
| 405 * standard time, the amount of daylight saving offset adjustment, the annua
l start | |
| 406 * time rule and the start/until years. The input DateTimeRule object is ad
opted | |
| 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_YEA
R. | |
| 417 * @stable ICU 3.8 | |
| 418 */ | |
| 419 AnnualTimeZoneRule(const UnicodeString& name, int32_t rawOffset, int32_t dst
Savings, | |
| 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 semantical
ly 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 semantic
ally 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 semantical
ly 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 semantic
ally 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 d
ate/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 ru
le | |
| 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 prevDSTSav
ings, 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 me
thod | |
| 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 thi
s 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 ru
le | |
| 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 take
s effect. | |
| 523 * @return true if the start time is available. When false is returned, ou
tput parameter | |
| 524 * "result" is unchanged. | |
| 525 * @stable ICU 3.8 | |
| 526 */ | |
| 527 virtual UBool getFirstStart(int32_t prevRawOffset, int32_t prevDSTSavings, U
Date& 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 ru
le | |
| 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 eff
ect. | |
| 536 * @return true if the start time is available. When false is returned, ou
tput parameter | |
| 537 * "result" is unchanged. | |
| 538 * @stable ICU 3.8 | |
| 539 */ | |
| 540 virtual UBool getFinalStart(int32_t prevRawOffset, int32_t prevDSTSavings, U
Date& 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 b
e returned. | |
| 545 * @param prevRawOffset The standard time offset from UTC before this ru
le | |
| 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 eff
ect after | |
| 551 * the specified base time. | |
| 552 * @return true if the start time is available. When false is returned, ou
tput parameter | |
| 553 * "result" is unchanged. | |
| 554 * @stable ICU 3.8 | |
| 555 */ | |
| 556 virtual UBool getNextStart(UDate base, int32_t prevRawOffset, int32_t prevDS
TSavings, | |
| 557 UBool inclusive, UDate& result) const; | |
| 558 | |
| 559 /** | |
| 560 * Gets the most recent time when this rule takes effect before the specifie
d 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 ru
le | |
| 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 tak
es effect before | |
| 568 * the specified base time. | |
| 569 * @return true if the start time is available. When false is returned, ou
tput parameter | |
| 570 * "result" is unchanged. | |
| 571 * @stable ICU 3.8 | |
| 572 */ | |
| 573 virtual UBool getPreviousStart(UDate base, int32_t prevRawOffset, int32_t pr
evDSTSavings, | |
| 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 ti
mes 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 of
fset 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::TimeRuleTy
pe 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 semantical
ly 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 semantic
ally 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 semantical
ly 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 semantic
ally 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 valu
e | |
| 686 * is either <code>DateTimeRule::WALL_TIME</code> or <code>STANDARD_TIME</co
de> | |
| 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 me
thod | |
| 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 thi
s 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 ru
le | |
| 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 take
s effect. | |
| 729 * @return true if the start time is available. When false is returned, ou
tput parameter | |
| 730 * "result" is unchanged. | |
| 731 * @stable ICU 3.8 | |
| 732 */ | |
| 733 virtual UBool getFirstStart(int32_t prevRawOffset, int32_t prevDSTSavings, U
Date& 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 ru
le | |
| 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 eff
ect. | |
| 742 * @return true if the start time is available. When false is returned, ou
tput parameter | |
| 743 * "result" is unchanged. | |
| 744 * @stable ICU 3.8 | |
| 745 */ | |
| 746 virtual UBool getFinalStart(int32_t prevRawOffset, int32_t prevDSTSavings, U
Date& 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 b
e returned. | |
| 751 * @param prevRawOffset The standard time offset from UTC before this ru
le | |
| 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 eff
ect after | |
| 757 * the specified base time. | |
| 758 * @return true if the start time is available. When false is returned, ou
tput parameter | |
| 759 * "result" is unchanged. | |
| 760 * @stable ICU 3.8 | |
| 761 */ | |
| 762 virtual UBool getNextStart(UDate base, int32_t prevRawOffset, int32_t prevDS
TSavings, | |
| 763 UBool inclusive, UDate& result) const; | |
| 764 | |
| 765 /** | |
| 766 * Gets the most recent time when this rule takes effect before the specifie
d 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 ru
le | |
| 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 tak
es effect before | |
| 774 * the specified base time. | |
| 775 * @return true if the start time is available. When false is returned, ou
tput parameter | |
| 776 * "result" is unchanged. | |
| 777 * @stable ICU 3.8 | |
| 778 */ | |
| 779 virtual UBool getPreviousStart(UDate base, int32_t prevRawOffset, int32_t pr
evDSTSavings, | |
| 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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 18836004:
Move ICU headers from public/{common,i18n} to source/{common,i18n} (Closed)
Base URL: https://chromium.googlesource.com/chromium/deps/icu46.git@master