| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 *******************************************************************************
* | |
| 3 * Copyright (C) 1997-2009, International Business Machines
* | |
| 4 * Corporation and others. All Rights Reserved.
* | |
| 5 *******************************************************************************
* | |
| 6 * | |
| 7 * File SIMPLETZ.H | |
| 8 * | |
| 9 * Modification History: | |
| 10 * | |
| 11 * Date Name Description | |
| 12 * 04/21/97 aliu Overhauled header. | |
| 13 * 08/10/98 stephen JDK 1.2 sync | |
| 14 * Added setStartRule() / setEndRule() overloads | |
| 15 * Added hasSameRules() | |
| 16 * 09/02/98 stephen Added getOffset(monthLen) | |
| 17 * Changed getOffset() to take UErrorCode | |
| 18 * 07/09/99 stephen Removed millisPerHour (unused, for HP compiler) | |
| 19 * 12/02/99 aliu Added TimeMode and constructor and setStart/EndRule | |
| 20 * methods that take TimeMode. Added to docs. | |
| 21 *******************************************************************************
* | |
| 22 */ | |
| 23 | |
| 24 #ifndef SIMPLETZ_H | |
| 25 #define SIMPLETZ_H | |
| 26 | |
| 27 #include "unicode/utypes.h" | |
| 28 | |
| 29 /** | |
| 30 * \file | |
| 31 * \brief C++ API: SimpleTimeZone is a concrete subclass of TimeZone. | |
| 32 */ | |
| 33 | |
| 34 #if !UCONFIG_NO_FORMATTING | |
| 35 | |
| 36 #include "unicode/basictz.h" | |
| 37 | |
| 38 U_NAMESPACE_BEGIN | |
| 39 | |
| 40 // forward declaration | |
| 41 class InitialTimeZoneRule; | |
| 42 class TimeZoneTransition; | |
| 43 class AnnualTimeZoneRule; | |
| 44 | |
| 45 /** | |
| 46 * <code>SimpleTimeZone</code> is a concrete subclass of <code>TimeZone</code> | |
| 47 * that represents a time zone for use with a Gregorian calendar. This | |
| 48 * class does not handle historical changes. | |
| 49 * <P> | |
| 50 * When specifying daylight-savings-time begin and end dates, use a negative val
ue for | |
| 51 * <code>dayOfWeekInMonth</code> to indicate that <code>SimpleTimeZone</code> sh
ould | |
| 52 * count from the end of the month backwards. For example, if Daylight Savings | |
| 53 * Time starts or ends at the last Sunday a month, use <code>dayOfWeekInMonth =
-1</code> | |
| 54 * along with <code>dayOfWeek = UCAL_SUNDAY</code> to specify the rule. | |
| 55 * | |
| 56 * @see Calendar | |
| 57 * @see GregorianCalendar | |
| 58 * @see TimeZone | |
| 59 * @author D. Goldsmith, Mark Davis, Chen-Lieh Huang, Alan Liu | |
| 60 */ | |
| 61 class U_I18N_API SimpleTimeZone: public BasicTimeZone { | |
| 62 public: | |
| 63 | |
| 64 /** | |
| 65 * TimeMode is used, together with a millisecond offset after | |
| 66 * midnight, to specify a rule transition time. Most rules | |
| 67 * transition at a local wall time, that is, according to the | |
| 68 * current time in effect, either standard, or DST. However, some | |
| 69 * rules transition at local standard time, and some at a specific | |
| 70 * UTC time. Although it might seem that all times could be | |
| 71 * converted to wall time, thus eliminating the need for this | |
| 72 * parameter, this is not the case. | |
| 73 * @stable ICU 2.0 | |
| 74 */ | |
| 75 enum TimeMode { | |
| 76 WALL_TIME = 0, | |
| 77 STANDARD_TIME, | |
| 78 UTC_TIME | |
| 79 }; | |
| 80 | |
| 81 /** | |
| 82 * Copy constructor | |
| 83 * @param source the object to be copied. | |
| 84 * @stable ICU 2.0 | |
| 85 */ | |
| 86 SimpleTimeZone(const SimpleTimeZone& source); | |
| 87 | |
| 88 /** | |
| 89 * Default assignment operator | |
| 90 * @param right the object to be copied. | |
| 91 * @stable ICU 2.0 | |
| 92 */ | |
| 93 SimpleTimeZone& operator=(const SimpleTimeZone& right); | |
| 94 | |
| 95 /** | |
| 96 * Destructor | |
| 97 * @stable ICU 2.0 | |
| 98 */ | |
| 99 virtual ~SimpleTimeZone(); | |
| 100 | |
| 101 /** | |
| 102 * Returns true if the two TimeZone objects are equal; that is, they have | |
| 103 * the same ID, raw GMT offset, and DST rules. | |
| 104 * | |
| 105 * @param that The SimpleTimeZone object to be compared with. | |
| 106 * @return True if the given time zone is equal to this time zone; fals
e | |
| 107 * otherwise. | |
| 108 * @stable ICU 2.0 | |
| 109 */ | |
| 110 virtual UBool operator==(const TimeZone& that) const; | |
| 111 | |
| 112 /** | |
| 113 * Constructs a SimpleTimeZone with the given raw GMT offset and time zone I
D, | |
| 114 * and which doesn't observe daylight savings time. Normally you should use | |
| 115 * TimeZone::createInstance() to create a TimeZone instead of creating a | |
| 116 * SimpleTimeZone directly with this constructor. | |
| 117 * | |
| 118 * @param rawOffsetGMT The given base time zone offset to GMT. | |
| 119 * @param ID The timezone ID which is obtained from | |
| 120 * TimeZone.getAvailableIDs. | |
| 121 * @stable ICU 2.0 | |
| 122 */ | |
| 123 SimpleTimeZone(int32_t rawOffsetGMT, const UnicodeString& ID); | |
| 124 | |
| 125 /** | |
| 126 * Construct a SimpleTimeZone with the given raw GMT offset, time zone ID, | |
| 127 * and times to start and end daylight savings time. To create a TimeZone th
at | |
| 128 * doesn't observe daylight savings time, don't use this constructor; use | |
| 129 * SimpleTimeZone(rawOffset, ID) instead. Normally, you should use | |
| 130 * TimeZone.createInstance() to create a TimeZone instead of creating a | |
| 131 * SimpleTimeZone directly with this constructor. | |
| 132 * <P> | |
| 133 * Various types of daylight-savings time rules can be specfied by using dif
ferent | |
| 134 * values for startDay and startDayOfWeek and endDay and endDayOfWeek. For
a | |
| 135 * complete explanation of how these parameters work, see the documentation
for | |
| 136 * setStartRule(). | |
| 137 * | |
| 138 * @param rawOffsetGMT The new SimpleTimeZone's raw GMT offset | |
| 139 * @param ID The new SimpleTimeZone's time zone ID. | |
| 140 * @param savingsStartMonth The daylight savings starting month. Month is | |
| 141 * 0-based. eg, 0 for January. | |
| 142 * @param savingsStartDayOfWeekInMonth The daylight savings starting | |
| 143 * day-of-week-in-month. See setStartRule() for a | |
| 144 * complete explanation. | |
| 145 * @param savingsStartDayOfWeek The daylight savings starting day-of-week. | |
| 146 * See setStartRule() for a complete explanation. | |
| 147 * @param savingsStartTime The daylight savings starting time, expressed as
the | |
| 148 * number of milliseconds after midnight. | |
| 149 * @param savingsEndMonth The daylight savings ending month. Month is | |
| 150 * 0-based. eg, 0 for January. | |
| 151 * @param savingsEndDayOfWeekInMonth The daylight savings ending day-of-
week-in-month. | |
| 152 * See setStartRule() for a complete explanation. | |
| 153 * @param savingsEndDayOfWeek The daylight savings ending day-of-week. | |
| 154 * See setStartRule() for a complete explanation. | |
| 155 * @param savingsEndTime The daylight savings ending time, expressed as t
he | |
| 156 * number of milliseconds after midnight. | |
| 157 * @param status An UErrorCode to receive the status. | |
| 158 * @stable ICU 2.0 | |
| 159 */ | |
| 160 SimpleTimeZone(int32_t rawOffsetGMT, const UnicodeString& ID, | |
| 161 int8_t savingsStartMonth, int8_t savingsStartDayOfWeekInMonth, | |
| 162 int8_t savingsStartDayOfWeek, int32_t savingsStartTime, | |
| 163 int8_t savingsEndMonth, int8_t savingsEndDayOfWeekInMonth, | |
| 164 int8_t savingsEndDayOfWeek, int32_t savingsEndTime, | |
| 165 UErrorCode& status); | |
| 166 /** | |
| 167 * Construct a SimpleTimeZone with the given raw GMT offset, time zone ID, | |
| 168 * and times to start and end daylight savings time. To create a TimeZone th
at | |
| 169 * doesn't observe daylight savings time, don't use this constructor; use | |
| 170 * SimpleTimeZone(rawOffset, ID) instead. Normally, you should use | |
| 171 * TimeZone.createInstance() to create a TimeZone instead of creating a | |
| 172 * SimpleTimeZone directly with this constructor. | |
| 173 * <P> | |
| 174 * Various types of daylight-savings time rules can be specfied by using dif
ferent | |
| 175 * values for startDay and startDayOfWeek and endDay and endDayOfWeek. For
a | |
| 176 * complete explanation of how these parameters work, see the documentation
for | |
| 177 * setStartRule(). | |
| 178 * | |
| 179 * @param rawOffsetGMT The new SimpleTimeZone's raw GMT offset | |
| 180 * @param ID The new SimpleTimeZone's time zone ID. | |
| 181 * @param savingsStartMonth The daylight savings starting month. Month is | |
| 182 * 0-based. eg, 0 for January. | |
| 183 * @param savingsStartDayOfWeekInMonth The daylight savings starting | |
| 184 * day-of-week-in-month. See setStartRule() for a | |
| 185 * complete explanation. | |
| 186 * @param savingsStartDayOfWeek The daylight savings starting day-of-week. | |
| 187 * See setStartRule() for a complete explanation. | |
| 188 * @param savingsStartTime The daylight savings starting time, expressed as
the | |
| 189 * number of milliseconds after midnight. | |
| 190 * @param savingsEndMonth The daylight savings ending month. Month is | |
| 191 * 0-based. eg, 0 for January. | |
| 192 * @param savingsEndDayOfWeekInMonth The daylight savings ending day-of-
week-in-month. | |
| 193 * See setStartRule() for a complete explanation. | |
| 194 * @param savingsEndDayOfWeek The daylight savings ending day-of-week. | |
| 195 * See setStartRule() for a complete explanation. | |
| 196 * @param savingsEndTime The daylight savings ending time, expressed as t
he | |
| 197 * number of milliseconds after midnight. | |
| 198 * @param savingsDST The number of milliseconds added to standard tim
e | |
| 199 * to get DST time. Default is one hour. | |
| 200 * @param status An UErrorCode to receive the status. | |
| 201 * @stable ICU 2.0 | |
| 202 */ | |
| 203 SimpleTimeZone(int32_t rawOffsetGMT, const UnicodeString& ID, | |
| 204 int8_t savingsStartMonth, int8_t savingsStartDayOfWeekInMonth, | |
| 205 int8_t savingsStartDayOfWeek, int32_t savingsStartTime, | |
| 206 int8_t savingsEndMonth, int8_t savingsEndDayOfWeekInMonth, | |
| 207 int8_t savingsEndDayOfWeek, int32_t savingsEndTime, | |
| 208 int32_t savingsDST, UErrorCode& status); | |
| 209 | |
| 210 /** | |
| 211 * Construct a SimpleTimeZone with the given raw GMT offset, time zone ID, | |
| 212 * and times to start and end daylight savings time. To create a TimeZone th
at | |
| 213 * doesn't observe daylight savings time, don't use this constructor; use | |
| 214 * SimpleTimeZone(rawOffset, ID) instead. Normally, you should use | |
| 215 * TimeZone.createInstance() to create a TimeZone instead of creating a | |
| 216 * SimpleTimeZone directly with this constructor. | |
| 217 * <P> | |
| 218 * Various types of daylight-savings time rules can be specfied by using dif
ferent | |
| 219 * values for startDay and startDayOfWeek and endDay and endDayOfWeek. For
a | |
| 220 * complete explanation of how these parameters work, see the documentation
for | |
| 221 * setStartRule(). | |
| 222 * | |
| 223 * @param rawOffsetGMT The new SimpleTimeZone's raw GMT offset | |
| 224 * @param ID The new SimpleTimeZone's time zone ID. | |
| 225 * @param savingsStartMonth The daylight savings starting month. Month is | |
| 226 * 0-based. eg, 0 for January. | |
| 227 * @param savingsStartDayOfWeekInMonth The daylight savings starting | |
| 228 * day-of-week-in-month. See setStartRule() for a | |
| 229 * complete explanation. | |
| 230 * @param savingsStartDayOfWeek The daylight savings starting day-of-week. | |
| 231 * See setStartRule() for a complete explanation. | |
| 232 * @param savingsStartTime The daylight savings starting time, expressed as
the | |
| 233 * number of milliseconds after midnight. | |
| 234 * @param savingsStartTimeMode Whether the start time is local wall time, lo
cal | |
| 235 * standard time, or UTC time. Default is local wal
l time. | |
| 236 * @param savingsEndMonth The daylight savings ending month. Month is | |
| 237 * 0-based. eg, 0 for January. | |
| 238 * @param savingsEndDayOfWeekInMonth The daylight savings ending day-of-
week-in-month. | |
| 239 * See setStartRule() for a complete explanation. | |
| 240 * @param savingsEndDayOfWeek The daylight savings ending day-of-week. | |
| 241 * See setStartRule() for a complete explanation. | |
| 242 * @param savingsEndTime The daylight savings ending time, expressed as t
he | |
| 243 * number of milliseconds after midnight. | |
| 244 * @param savingsEndTimeMode Whether the end time is local wall time, local | |
| 245 * standard time, or UTC time. Default is local wal
l time. | |
| 246 * @param savingsDST The number of milliseconds added to standard tim
e | |
| 247 * to get DST time. Default is one hour. | |
| 248 * @param status An UErrorCode to receive the status. | |
| 249 * @stable ICU 2.0 | |
| 250 */ | |
| 251 SimpleTimeZone(int32_t rawOffsetGMT, const UnicodeString& ID, | |
| 252 int8_t savingsStartMonth, int8_t savingsStartDayOfWeekInMonth, | |
| 253 int8_t savingsStartDayOfWeek, int32_t savingsStartTime, | |
| 254 TimeMode savingsStartTimeMode, | |
| 255 int8_t savingsEndMonth, int8_t savingsEndDayOfWeekInMonth, | |
| 256 int8_t savingsEndDayOfWeek, int32_t savingsEndTime, TimeMode savingsEndT
imeMode, | |
| 257 int32_t savingsDST, UErrorCode& status); | |
| 258 | |
| 259 /** | |
| 260 * Sets the daylight savings starting year, that is, the year this time zone
began | |
| 261 * observing its specified daylight savings time rules. The time zone is co
nsidered | |
| 262 * not to observe daylight savings time prior to that year; SimpleTimeZone d
oesn't | |
| 263 * support historical daylight-savings-time rules. | |
| 264 * @param year the daylight savings starting year. | |
| 265 * @stable ICU 2.0 | |
| 266 */ | |
| 267 void setStartYear(int32_t year); | |
| 268 | |
| 269 /** | |
| 270 * Sets the daylight savings starting rule. For example, in the U.S., Daylig
ht Savings | |
| 271 * Time starts at the second Sunday in March, at 2 AM in standard time. | |
| 272 * Therefore, you can set the start rule by calling: | |
| 273 * setStartRule(UCAL_MARCH, 2, UCAL_SUNDAY, 2*60*60*1000); | |
| 274 * The dayOfWeekInMonth and dayOfWeek parameters together specify how to cal
culate | |
| 275 * the exact starting date. Their exact meaning depend on their respective
signs, | |
| 276 * allowing various types of rules to be constructed, as follows: | |
| 277 * <ul> | |
| 278 * <li>If both dayOfWeekInMonth and dayOfWeek are positive, they specify t
he | |
| 279 * day of week in the month (e.g., (2, WEDNESDAY) is the second Wednes
day | |
| 280 * of the month).</li> | |
| 281 * <li>If dayOfWeek is positive and dayOfWeekInMonth is negative, they spe
cify | |
| 282 * the day of week in the month counting backward from the end of the
month. | |
| 283 * (e.g., (-1, MONDAY) is the last Monday in the month)</li> | |
| 284 * <li>If dayOfWeek is zero and dayOfWeekInMonth is positive, dayOfWeekInM
onth | |
| 285 * specifies the day of the month, regardless of what day of the week
it is. | |
| 286 * (e.g., (10, 0) is the tenth day of the month)</li> | |
| 287 * <li>If dayOfWeek is zero and dayOfWeekInMonth is negative, dayOfWeekInM
onth | |
| 288 * specifies the day of the month counting backward from the end of th
e | |
| 289 * month, regardless of what day of the week it is (e.g., (-2, 0) is t
he | |
| 290 * next-to-last day of the month).</li> | |
| 291 * <li>If dayOfWeek is negative and dayOfWeekInMonth is positive, they spe
cify the | |
| 292 * first specified day of the week on or after the specfied day of the
month. | |
| 293 * (e.g., (15, -SUNDAY) is the first Sunday after the 15th of the mont
h | |
| 294 * [or the 15th itself if the 15th is a Sunday].)</li> | |
| 295 * <li>If dayOfWeek and DayOfWeekInMonth are both negative, they specify t
he | |
| 296 * last specified day of the week on or before the specified day of th
e month. | |
| 297 * (e.g., (-20, -TUESDAY) is the last Tuesday before the 20th of the m
onth | |
| 298 * [or the 20th itself if the 20th is a Tuesday].)</li> | |
| 299 * </ul> | |
| 300 * @param month the daylight savings starting month. Month is 0-based. | |
| 301 * eg, 0 for January. | |
| 302 * @param dayOfWeekInMonth the daylight savings starting | |
| 303 * day-of-week-in-month. Please see the member description for an example. | |
| 304 * @param dayOfWeek the daylight savings starting day-of-week. Please see | |
| 305 * the member description for an example. | |
| 306 * @param time the daylight savings starting time. Please see the member | |
| 307 * description for an example. | |
| 308 * @param status An UErrorCode | |
| 309 * @stable ICU 2.0 | |
| 310 */ | |
| 311 void setStartRule(int32_t month, int32_t dayOfWeekInMonth, int32_t dayOfWeek
, | |
| 312 int32_t time, UErrorCode& status); | |
| 313 /** | |
| 314 * Sets the daylight savings starting rule. For example, in the U.S., Daylig
ht Savings | |
| 315 * Time starts at the second Sunday in March, at 2 AM in standard time. | |
| 316 * Therefore, you can set the start rule by calling: | |
| 317 * setStartRule(UCAL_MARCH, 2, UCAL_SUNDAY, 2*60*60*1000); | |
| 318 * The dayOfWeekInMonth and dayOfWeek parameters together specify how to cal
culate | |
| 319 * the exact starting date. Their exact meaning depend on their respective
signs, | |
| 320 * allowing various types of rules to be constructed, as follows: | |
| 321 * <ul> | |
| 322 * <li>If both dayOfWeekInMonth and dayOfWeek are positive, they specify t
he | |
| 323 * day of week in the month (e.g., (2, WEDNESDAY) is the second Wednes
day | |
| 324 * of the month).</li> | |
| 325 * <li>If dayOfWeek is positive and dayOfWeekInMonth is negative, they spe
cify | |
| 326 * the day of week in the month counting backward from the end of the
month. | |
| 327 * (e.g., (-1, MONDAY) is the last Monday in the month)</li> | |
| 328 * <li>If dayOfWeek is zero and dayOfWeekInMonth is positive, dayOfWeekInM
onth | |
| 329 * specifies the day of the month, regardless of what day of the week
it is. | |
| 330 * (e.g., (10, 0) is the tenth day of the month)</li> | |
| 331 * <li>If dayOfWeek is zero and dayOfWeekInMonth is negative, dayOfWeekInM
onth | |
| 332 * specifies the day of the month counting backward from the end of th
e | |
| 333 * month, regardless of what day of the week it is (e.g., (-2, 0) is t
he | |
| 334 * next-to-last day of the month).</li> | |
| 335 * <li>If dayOfWeek is negative and dayOfWeekInMonth is positive, they spe
cify the | |
| 336 * first specified day of the week on or after the specfied day of the
month. | |
| 337 * (e.g., (15, -SUNDAY) is the first Sunday after the 15th of the mont
h | |
| 338 * [or the 15th itself if the 15th is a Sunday].)</li> | |
| 339 * <li>If dayOfWeek and DayOfWeekInMonth are both negative, they specify t
he | |
| 340 * last specified day of the week on or before the specified day of th
e month. | |
| 341 * (e.g., (-20, -TUESDAY) is the last Tuesday before the 20th of the m
onth | |
| 342 * [or the 20th itself if the 20th is a Tuesday].)</li> | |
| 343 * </ul> | |
| 344 * @param month the daylight savings starting month. Month is 0-based. | |
| 345 * eg, 0 for January. | |
| 346 * @param dayOfWeekInMonth the daylight savings starting | |
| 347 * day-of-week-in-month. Please see the member description for an example. | |
| 348 * @param dayOfWeek the daylight savings starting day-of-week. Please see | |
| 349 * the member description for an example. | |
| 350 * @param time the daylight savings starting time. Please see the member | |
| 351 * description for an example. | |
| 352 * @param mode whether the time is local wall time, local standard time, | |
| 353 * or UTC time. Default is local wall time. | |
| 354 * @param status An UErrorCode | |
| 355 * @stable ICU 2.0 | |
| 356 */ | |
| 357 void setStartRule(int32_t month, int32_t dayOfWeekInMonth, int32_t dayOfWeek
, | |
| 358 int32_t time, TimeMode mode, UErrorCode& status); | |
| 359 | |
| 360 /** | |
| 361 * Sets the DST start rule to a fixed date within a month. | |
| 362 * | |
| 363 * @param month The month in which this rule occurs (0-based). | |
| 364 * @param dayOfMonth The date in that month (1-based). | |
| 365 * @param time The time of that day (number of millis after midnigh
t) | |
| 366 * when DST takes effect in local wall time, which is | |
| 367 * standard time in this case. | |
| 368 * @param status An UErrorCode | |
| 369 * @stable ICU 2.0 | |
| 370 */ | |
| 371 void setStartRule(int32_t month, int32_t dayOfMonth, int32_t time, | |
| 372 UErrorCode& status); | |
| 373 /** | |
| 374 * Sets the DST start rule to a fixed date within a month. | |
| 375 * | |
| 376 * @param month The month in which this rule occurs (0-based). | |
| 377 * @param dayOfMonth The date in that month (1-based). | |
| 378 * @param time The time of that day (number of millis after midnigh
t) | |
| 379 * when DST takes effect in local wall time, which is | |
| 380 * standard time in this case. | |
| 381 * @param mode whether the time is local wall time, local standard time, | |
| 382 * or UTC time. Default is local wall time. | |
| 383 * @param status An UErrorCode | |
| 384 * @stable ICU 2.0 | |
| 385 */ | |
| 386 void setStartRule(int32_t month, int32_t dayOfMonth, int32_t time, | |
| 387 TimeMode mode, UErrorCode& status); | |
| 388 | |
| 389 /** | |
| 390 * Sets the DST start rule to a weekday before or after a give date within | |
| 391 * a month, e.g., the first Monday on or after the 8th. | |
| 392 * | |
| 393 * @param month The month in which this rule occurs (0-based). | |
| 394 * @param dayOfMonth A date within that month (1-based). | |
| 395 * @param dayOfWeek The day of the week on which this rule occurs. | |
| 396 * @param time The time of that day (number of millis after midnigh
t) | |
| 397 * when DST takes effect in local wall time, which is | |
| 398 * standard time in this case. | |
| 399 * @param after If true, this rule selects the first dayOfWeek on | |
| 400 * or after dayOfMonth. If false, this rule selects | |
| 401 * the last dayOfWeek on or before dayOfMonth. | |
| 402 * @param status An UErrorCode | |
| 403 * @stable ICU 2.0 | |
| 404 */ | |
| 405 void setStartRule(int32_t month, int32_t dayOfMonth, int32_t dayOfWeek, | |
| 406 int32_t time, UBool after, UErrorCode& status); | |
| 407 /** | |
| 408 * Sets the DST start rule to a weekday before or after a give date within | |
| 409 * a month, e.g., the first Monday on or after the 8th. | |
| 410 * | |
| 411 * @param month The month in which this rule occurs (0-based). | |
| 412 * @param dayOfMonth A date within that month (1-based). | |
| 413 * @param dayOfWeek The day of the week on which this rule occurs. | |
| 414 * @param time The time of that day (number of millis after midnigh
t) | |
| 415 * when DST takes effect in local wall time, which is | |
| 416 * standard time in this case. | |
| 417 * @param mode whether the time is local wall time, local standard time, | |
| 418 * or UTC time. Default is local wall time. | |
| 419 * @param after If true, this rule selects the first dayOfWeek on | |
| 420 * or after dayOfMonth. If false, this rule selects | |
| 421 * the last dayOfWeek on or before dayOfMonth. | |
| 422 * @param status An UErrorCode | |
| 423 * @stable ICU 2.0 | |
| 424 */ | |
| 425 void setStartRule(int32_t month, int32_t dayOfMonth, int32_t dayOfWeek, | |
| 426 int32_t time, TimeMode mode, UBool after, UErrorCode& stat
us); | |
| 427 | |
| 428 /** | |
| 429 * Sets the daylight savings ending rule. For example, if Daylight | |
| 430 * Savings Time ends at the last (-1) Sunday in October, at 2 AM in standard
time. | |
| 431 * Therefore, you can set the end rule by calling: | |
| 432 * <pre> | |
| 433 * setEndRule(UCAL_OCTOBER, -1, UCAL_SUNDAY, 2*60*60*1000); | |
| 434 * </pre> | |
| 435 * Various other types of rules can be specified by manipulating the dayOfWe
ek | |
| 436 * and dayOfWeekInMonth parameters. For complete details, see the documenta
tion | |
| 437 * for setStartRule(). | |
| 438 * | |
| 439 * @param month the daylight savings ending month. Month is 0-based. | |
| 440 * eg, 0 for January. | |
| 441 * @param dayOfWeekInMonth the daylight savings ending | |
| 442 * day-of-week-in-month. See setStartRule() for a complete explanation. | |
| 443 * @param dayOfWeek the daylight savings ending day-of-week. See setStartRul
e() | |
| 444 * for a complete explanation. | |
| 445 * @param time the daylight savings ending time. Please see the member | |
| 446 * description for an example. | |
| 447 * @param status An UErrorCode | |
| 448 * @stable ICU 2.0 | |
| 449 */ | |
| 450 void setEndRule(int32_t month, int32_t dayOfWeekInMonth, int32_t dayOfWeek, | |
| 451 int32_t time, UErrorCode& status); | |
| 452 | |
| 453 /** | |
| 454 * Sets the daylight savings ending rule. For example, if Daylight | |
| 455 * Savings Time ends at the last (-1) Sunday in October, at 2 AM in standard
time. | |
| 456 * Therefore, you can set the end rule by calling: | |
| 457 * <pre> | |
| 458 * setEndRule(UCAL_OCTOBER, -1, UCAL_SUNDAY, 2*60*60*1000); | |
| 459 * </pre> | |
| 460 * Various other types of rules can be specified by manipulating the dayOfWe
ek | |
| 461 * and dayOfWeekInMonth parameters. For complete details, see the documenta
tion | |
| 462 * for setStartRule(). | |
| 463 * | |
| 464 * @param month the daylight savings ending month. Month is 0-based. | |
| 465 * eg, 0 for January. | |
| 466 * @param dayOfWeekInMonth the daylight savings ending | |
| 467 * day-of-week-in-month. See setStartRule() for a complete explanation. | |
| 468 * @param dayOfWeek the daylight savings ending day-of-week. See setStartRul
e() | |
| 469 * for a complete explanation. | |
| 470 * @param time the daylight savings ending time. Please see the member | |
| 471 * description for an example. | |
| 472 * @param mode whether the time is local wall time, local standard time, | |
| 473 * or UTC time. Default is local wall time. | |
| 474 * @param status An UErrorCode | |
| 475 * @stable ICU 2.0 | |
| 476 */ | |
| 477 void setEndRule(int32_t month, int32_t dayOfWeekInMonth, int32_t dayOfWeek, | |
| 478 int32_t time, TimeMode mode, UErrorCode& status); | |
| 479 | |
| 480 /** | |
| 481 * Sets the DST end rule to a fixed date within a month. | |
| 482 * | |
| 483 * @param month The month in which this rule occurs (0-based). | |
| 484 * @param dayOfMonth The date in that month (1-based). | |
| 485 * @param time The time of that day (number of millis after midnigh
t) | |
| 486 * when DST ends in local wall time, which is daylight | |
| 487 * time in this case. | |
| 488 * @param status An UErrorCode | |
| 489 * @stable ICU 2.0 | |
| 490 */ | |
| 491 void setEndRule(int32_t month, int32_t dayOfMonth, int32_t time, UErrorCode&
status); | |
| 492 | |
| 493 /** | |
| 494 * Sets the DST end rule to a fixed date within a month. | |
| 495 * | |
| 496 * @param month The month in which this rule occurs (0-based). | |
| 497 * @param dayOfMonth The date in that month (1-based). | |
| 498 * @param time The time of that day (number of millis after midnigh
t) | |
| 499 * when DST ends in local wall time, which is daylight | |
| 500 * time in this case. | |
| 501 * @param mode whether the time is local wall time, local standard time, | |
| 502 * or UTC time. Default is local wall time. | |
| 503 * @param status An UErrorCode | |
| 504 * @stable ICU 2.0 | |
| 505 */ | |
| 506 void setEndRule(int32_t month, int32_t dayOfMonth, int32_t time, | |
| 507 TimeMode mode, UErrorCode& status); | |
| 508 | |
| 509 /** | |
| 510 * Sets the DST end rule to a weekday before or after a give date within | |
| 511 * a month, e.g., the first Monday on or after the 8th. | |
| 512 * | |
| 513 * @param month The month in which this rule occurs (0-based). | |
| 514 * @param dayOfMonth A date within that month (1-based). | |
| 515 * @param dayOfWeek The day of the week on which this rule occurs. | |
| 516 * @param time The time of that day (number of millis after midnigh
t) | |
| 517 * when DST ends in local wall time, which is daylight | |
| 518 * time in this case. | |
| 519 * @param after If true, this rule selects the first dayOfWeek on | |
| 520 * or after dayOfMonth. If false, this rule selects | |
| 521 * the last dayOfWeek on or before dayOfMonth. | |
| 522 * @param status An UErrorCode | |
| 523 * @stable ICU 2.0 | |
| 524 */ | |
| 525 void setEndRule(int32_t month, int32_t dayOfMonth, int32_t dayOfWeek, | |
| 526 int32_t time, UBool after, UErrorCode& status); | |
| 527 | |
| 528 /** | |
| 529 * Sets the DST end rule to a weekday before or after a give date within | |
| 530 * a month, e.g., the first Monday on or after the 8th. | |
| 531 * | |
| 532 * @param month The month in which this rule occurs (0-based). | |
| 533 * @param dayOfMonth A date within that month (1-based). | |
| 534 * @param dayOfWeek The day of the week on which this rule occurs. | |
| 535 * @param time The time of that day (number of millis after midnigh
t) | |
| 536 * when DST ends in local wall time, which is daylight | |
| 537 * time in this case. | |
| 538 * @param mode whether the time is local wall time, local standard time, | |
| 539 * or UTC time. Default is local wall time. | |
| 540 * @param after If true, this rule selects the first dayOfWeek on | |
| 541 * or after dayOfMonth. If false, this rule selects | |
| 542 * the last dayOfWeek on or before dayOfMonth. | |
| 543 * @param status An UErrorCode | |
| 544 * @stable ICU 2.0 | |
| 545 */ | |
| 546 void setEndRule(int32_t month, int32_t dayOfMonth, int32_t dayOfWeek, | |
| 547 int32_t time, TimeMode mode, UBool after, UErrorCode& status
); | |
| 548 | |
| 549 /** | |
| 550 * Returns the TimeZone's adjusted GMT offset (i.e., the number of milliseco
nds to add | |
| 551 * to GMT to get local time in this time zone, taking daylight savings time
into | |
| 552 * account) as of a particular reference date. The reference date is used t
o determine | |
| 553 * whether daylight savings time is in effect and needs to be figured into t
he offset | |
| 554 * that is returned (in other words, what is the adjusted GMT offset in this
time zone | |
| 555 * at this particular date and time?). For the time zones produced by creat
eTimeZone(), | |
| 556 * the reference data is specified according to the Gregorian calendar, and
the date | |
| 557 * and time fields are in GMT, NOT local time. | |
| 558 * | |
| 559 * @param era The reference date's era | |
| 560 * @param year The reference date's year | |
| 561 * @param month The reference date's month (0-based; 0 is January) | |
| 562 * @param day The reference date's day-in-month (1-based) | |
| 563 * @param dayOfWeek The reference date's day-of-week (1-based; 1 is Sunday) | |
| 564 * @param millis The reference date's milliseconds in day, UTT (NOT loca
l time). | |
| 565 * @param status An UErrorCode to receive the status. | |
| 566 * @return The offset in milliseconds to add to GMT to get local t
ime. | |
| 567 * @stable ICU 2.0 | |
| 568 */ | |
| 569 virtual int32_t getOffset(uint8_t era, int32_t year, int32_t month, int32_t
day, | |
| 570 uint8_t dayOfWeek, int32_t millis, UErrorCode& sta
tus) const; | |
| 571 | |
| 572 /** | |
| 573 * Gets the time zone offset, for current date, modified in case of | |
| 574 * daylight savings. This is the offset to add *to* UTC to get local time. | |
| 575 * @param era the era of the given date. | |
| 576 * @param year the year in the given date. | |
| 577 * @param month the month in the given date. | |
| 578 * Month is 0-based. e.g., 0 for January. | |
| 579 * @param day the day-in-month of the given date. | |
| 580 * @param dayOfWeek the day-of-week of the given date. | |
| 581 * @param milliseconds the millis in day in <em>standard</em> local time. | |
| 582 * @param monthLength the length of the given month in days. | |
| 583 * @param status An UErrorCode to receive the status. | |
| 584 * @return the offset to add *to* GMT to get local time. | |
| 585 * @stable ICU 2.0 | |
| 586 */ | |
| 587 virtual int32_t getOffset(uint8_t era, int32_t year, int32_t month, int32_t
day, | |
| 588 uint8_t dayOfWeek, int32_t milliseconds, | |
| 589 int32_t monthLength, UErrorCode& status) const; | |
| 590 /** | |
| 591 * Gets the time zone offset, for current date, modified in case of | |
| 592 * daylight savings. This is the offset to add *to* UTC to get local time. | |
| 593 * @param era the era of the given date. | |
| 594 * @param year the year in the given date. | |
| 595 * @param month the month in the given date. | |
| 596 * Month is 0-based. e.g., 0 for January. | |
| 597 * @param day the day-in-month of the given date. | |
| 598 * @param dayOfWeek the day-of-week of the given date. | |
| 599 * @param milliseconds the millis in day in <em>standard</em> local time. | |
| 600 * @param monthLength the length of the given month in days. | |
| 601 * @param prevMonthLength length of the previous month in days. | |
| 602 * @param status An UErrorCode to receive the status. | |
| 603 * @return the offset to add *to* GMT to get local time. | |
| 604 * @stable ICU 2.0 | |
| 605 */ | |
| 606 virtual int32_t getOffset(uint8_t era, int32_t year, int32_t month, int32_t
day, | |
| 607 uint8_t dayOfWeek, int32_t milliseconds, | |
| 608 int32_t monthLength, int32_t prevMonthLength, | |
| 609 UErrorCode& status) const; | |
| 610 | |
| 611 /** | |
| 612 * Redeclared TimeZone method. This implementation simply calls | |
| 613 * the base class method, which otherwise would be hidden. | |
| 614 * @stable ICU 2.8 | |
| 615 */ | |
| 616 virtual void getOffset(UDate date, UBool local, int32_t& rawOffset, | |
| 617 int32_t& dstOffset, UErrorCode& ec) const; | |
| 618 | |
| 619 /** | |
| 620 * Get time zone offsets from local wall time. | |
| 621 * @internal | |
| 622 */ | |
| 623 virtual void getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int3
2_t duplicatedTimeOpt, | |
| 624 int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) /*const*/; | |
| 625 | |
| 626 /** | |
| 627 * Returns the TimeZone's raw GMT offset (i.e., the number of milliseconds t
o add | |
| 628 * to GMT to get local time, before taking daylight savings time into accoun
t). | |
| 629 * | |
| 630 * @return The TimeZone's raw GMT offset. | |
| 631 * @stable ICU 2.0 | |
| 632 */ | |
| 633 virtual int32_t getRawOffset(void) const; | |
| 634 | |
| 635 /** | |
| 636 * Sets the TimeZone's raw GMT offset (i.e., the number of milliseconds to a
dd | |
| 637 * to GMT to get local time, before taking daylight savings time into accoun
t). | |
| 638 * | |
| 639 * @param offsetMillis The new raw GMT offset for this time zone. | |
| 640 * @stable ICU 2.0 | |
| 641 */ | |
| 642 virtual void setRawOffset(int32_t offsetMillis); | |
| 643 | |
| 644 /** | |
| 645 * Sets the amount of time in ms that the clock is advanced during DST. | |
| 646 * @param millisSavedDuringDST the number of milliseconds the time is | |
| 647 * advanced with respect to standard time when the daylight savings rules | |
| 648 * are in effect. A positive number, typically one hour (3600000). | |
| 649 * @param status An UErrorCode to receive the status. | |
| 650 * @stable ICU 2.0 | |
| 651 */ | |
| 652 void setDSTSavings(int32_t millisSavedDuringDST, UErrorCode& status); | |
| 653 | |
| 654 /** | |
| 655 * Returns the amount of time in ms that the clock is advanced during DST. | |
| 656 * @return the number of milliseconds the time is | |
| 657 * advanced with respect to standard time when the daylight savings rules | |
| 658 * are in effect. A positive number, typically one hour (3600000). | |
| 659 * @stable ICU 2.0 | |
| 660 */ | |
| 661 virtual int32_t getDSTSavings(void) const; | |
| 662 | |
| 663 /** | |
| 664 * Queries if this TimeZone uses Daylight Savings Time. | |
| 665 * | |
| 666 * @return True if this TimeZone uses Daylight Savings Time; false otherwi
se. | |
| 667 * @stable ICU 2.0 | |
| 668 */ | |
| 669 virtual UBool useDaylightTime(void) const; | |
| 670 | |
| 671 /** | |
| 672 * Returns true if the given date is within the period when daylight savings
time | |
| 673 * is in effect; false otherwise. If the TimeZone doesn't observe daylight
savings | |
| 674 * time, this functions always returns false. | |
| 675 * This method is wasteful since it creates a new GregorianCalendar and | |
| 676 * deletes it each time it is called. This is a deprecated method | |
| 677 * and provided only for Java compatibility. | |
| 678 * | |
| 679 * @param date The date to test. | |
| 680 * @param status An UErrorCode to receive the status. | |
| 681 * @return true if the given date is in Daylight Savings Time; | |
| 682 * false otherwise. | |
| 683 * @deprecated ICU 2.4. Use Calendar::inDaylightTime() instead. | |
| 684 */ | |
| 685 virtual UBool inDaylightTime(UDate date, UErrorCode& status) const; | |
| 686 | |
| 687 /** | |
| 688 * Return true if this zone has the same rules and offset as another zone. | |
| 689 * @param other the TimeZone object to be compared with | |
| 690 * @return true if the given zone has the same rules and offset as this one | |
| 691 * @stable ICU 2.0 | |
| 692 */ | |
| 693 UBool hasSameRules(const TimeZone& other) const; | |
| 694 | |
| 695 /** | |
| 696 * Clones TimeZone objects polymorphically. Clients are responsible for dele
ting | |
| 697 * the TimeZone object cloned. | |
| 698 * | |
| 699 * @return A new copy of this TimeZone object. | |
| 700 * @stable ICU 2.0 | |
| 701 */ | |
| 702 virtual TimeZone* clone(void) const; | |
| 703 | |
| 704 /** | |
| 705 * Gets the first time zone transition after the base time. | |
| 706 * @param base The base time. | |
| 707 * @param inclusive Whether the base time is inclusive or not. | |
| 708 * @param result Receives the first transition after the base time. | |
| 709 * @return TRUE if the transition is found. | |
| 710 * @stable ICU 3.8 | |
| 711 */ | |
| 712 virtual UBool getNextTransition(UDate base, UBool inclusive, TimeZoneTransit
ion& result) /*const*/; | |
| 713 | |
| 714 /** | |
| 715 * Gets the most recent time zone transition before the base time. | |
| 716 * @param base The base time. | |
| 717 * @param inclusive Whether the base time is inclusive or not. | |
| 718 * @param result Receives the most recent transition before the base time
. | |
| 719 * @return TRUE if the transition is found. | |
| 720 * @stable ICU 3.8 | |
| 721 */ | |
| 722 virtual UBool getPreviousTransition(UDate base, UBool inclusive, TimeZoneTra
nsition& result) /*const*/; | |
| 723 | |
| 724 /** | |
| 725 * Returns the number of <code>TimeZoneRule</code>s which represents time tr
ansitions, | |
| 726 * for this time zone, that is, all <code>TimeZoneRule</code>s for this time
zone except | |
| 727 * <code>InitialTimeZoneRule</code>. The return value range is 0 or any pos
itive value. | |
| 728 * @param status Receives error status code. | |
| 729 * @return The number of <code>TimeZoneRule</code>s representing time transi
tions. | |
| 730 * @stable ICU 3.8 | |
| 731 */ | |
| 732 virtual int32_t countTransitionRules(UErrorCode& status) /*const*/; | |
| 733 | |
| 734 /** | |
| 735 * Gets the <code>InitialTimeZoneRule</code> and the set of <code>TimeZoneRu
le</code> | |
| 736 * which represent time transitions for this time zone. On successful retur
n, | |
| 737 * the argument initial points to non-NULL <code>InitialTimeZoneRule</code>
and | |
| 738 * the array trsrules is filled with 0 or multiple <code>TimeZoneRule</code> | |
| 739 * instances up to the size specified by trscount. The results are referenc
ing the | |
| 740 * rule instance held by this time zone instance. Therefore, after this tim
e zone | |
| 741 * is destructed, they are no longer available. | |
| 742 * @param initial Receives the initial timezone rule | |
| 743 * @param trsrules Receives the timezone transition rules | |
| 744 * @param trscount On input, specify the size of the array 'transitions
' receiving | |
| 745 * the timezone transition rules. On output, actual nu
mber of | |
| 746 * rules filled in the array will be set. | |
| 747 * @param status Receives error status code. | |
| 748 * @stable ICU 3.8 | |
| 749 */ | |
| 750 virtual void getTimeZoneRules(const InitialTimeZoneRule*& initial, | |
| 751 const TimeZoneRule* trsrules[], int32_t& trscount, UErrorCode& status) /
*const*/; | |
| 752 | |
| 753 | |
| 754 public: | |
| 755 | |
| 756 /** | |
| 757 * Override TimeZone Returns a unique class ID POLYMORPHICALLY. Pure virtual | |
| 758 * override. This method is to implement a simple version of RTTI, since not
all C++ | |
| 759 * compilers support genuine RTTI. Polymorphic operator==() and clone() meth
ods call | |
| 760 * this method. | |
| 761 * | |
| 762 * @return The class ID for this object. All objects of a given class have
the | |
| 763 * same class ID. Objects of other classes have different class ID
s. | |
| 764 * @stable ICU 2.0 | |
| 765 */ | |
| 766 virtual UClassID getDynamicClassID(void) const; | |
| 767 | |
| 768 /** | |
| 769 * Return the class ID for this class. This is useful only for comparing to
a return | |
| 770 * value from getDynamicClassID(). For example: | |
| 771 * <pre> | |
| 772 * . Base* polymorphic_pointer = createPolymorphicObject(); | |
| 773 * . if (polymorphic_pointer->getDynamicClassID() == | |
| 774 * . Derived::getStaticClassID()) ... | |
| 775 * </pre> | |
| 776 * @return The class ID for all objects of this class. | |
| 777 * @stable ICU 2.0 | |
| 778 */ | |
| 779 static UClassID U_EXPORT2 getStaticClassID(void); | |
| 780 | |
| 781 private: | |
| 782 /** | |
| 783 * Constants specifying values of startMode and endMode. | |
| 784 */ | |
| 785 enum EMode | |
| 786 { | |
| 787 DOM_MODE = 1, | |
| 788 DOW_IN_MONTH_MODE, | |
| 789 DOW_GE_DOM_MODE, | |
| 790 DOW_LE_DOM_MODE | |
| 791 }; | |
| 792 | |
| 793 SimpleTimeZone(); // default constructor not implemented | |
| 794 | |
| 795 /** | |
| 796 * Internal construction method. | |
| 797 * @param rawOffsetGMT The new SimpleTimeZone's raw GMT offset | |
| 798 * @param startMonth the month DST starts | |
| 799 * @param startDay the day DST starts | |
| 800 * @param startDayOfWeek the DOW DST starts | |
| 801 * @param startTime the time DST starts | |
| 802 * @param startTimeMode Whether the start time is local wall time, local | |
| 803 * standard time, or UTC time. Default is local wall
time. | |
| 804 * @param endMonth the month DST ends | |
| 805 * @param endDay the day DST ends | |
| 806 * @param endDayOfWeek the DOW DST ends | |
| 807 * @param endTime the time DST ends | |
| 808 * @param endTimeMode Whether the end time is local wall time, local | |
| 809 * standard time, or UTC time. Default is local wall
time. | |
| 810 * @param savingsDST The number of milliseconds added to standard time | |
| 811 * to get DST time. Default is one hour. | |
| 812 * @param status An UErrorCode to receive the status. | |
| 813 */ | |
| 814 void construct(int32_t rawOffsetGMT, | |
| 815 int8_t startMonth, int8_t startDay, int8_t startDayOfWeek, | |
| 816 int32_t startTime, TimeMode startTimeMode, | |
| 817 int8_t endMonth, int8_t endDay, int8_t endDayOfWeek, | |
| 818 int32_t endTime, TimeMode endTimeMode, | |
| 819 int32_t dstSavings, UErrorCode& status); | |
| 820 | |
| 821 /** | |
| 822 * Compare a given date in the year to a rule. Return 1, 0, or -1, depending | |
| 823 * on whether the date is after, equal to, or before the rule date. The | |
| 824 * millis are compared directly against the ruleMillis, so any | |
| 825 * standard-daylight adjustments must be handled by the caller. | |
| 826 * | |
| 827 * @return 1 if the date is after the rule date, -1 if the date is before | |
| 828 * the rule date, or 0 if the date is equal to the rule date. | |
| 829 */ | |
| 830 static int32_t compareToRule(int8_t month, int8_t monthLen, int8_t prevMonth
Len, | |
| 831 int8_t dayOfMonth, | |
| 832 int8_t dayOfWeek, int32_t millis, int32_t milli
sDelta, | |
| 833 EMode ruleMode, int8_t ruleMonth, int8_t ruleDa
yOfWeek, | |
| 834 int8_t ruleDay, int32_t ruleMillis); | |
| 835 | |
| 836 /** | |
| 837 * Given a set of encoded rules in startDay and startDayOfMonth, decode | |
| 838 * them and set the startMode appropriately. Do the same for endDay and | |
| 839 * endDayOfMonth. | |
| 840 * <P> | |
| 841 * Upon entry, the day of week variables may be zero or | |
| 842 * negative, in order to indicate special modes. The day of month | |
| 843 * variables may also be negative. | |
| 844 * <P> | |
| 845 * Upon exit, the mode variables will be | |
| 846 * set, and the day of week and day of month variables will be positive. | |
| 847 * <P> | |
| 848 * This method also recognizes a startDay or endDay of zero as indicating | |
| 849 * no DST. | |
| 850 */ | |
| 851 void decodeRules(UErrorCode& status); | |
| 852 void decodeStartRule(UErrorCode& status); | |
| 853 void decodeEndRule(UErrorCode& status); | |
| 854 | |
| 855 int8_t startMonth, startDay, startDayOfWeek; // the month, day, DOW, and t
ime DST starts | |
| 856 int32_t startTime; | |
| 857 TimeMode startTimeMode, endTimeMode; // Mode for startTime, endTime; see Tim
eMode | |
| 858 int8_t endMonth, endDay, endDayOfWeek; // the month, day, DOW, and time DST
ends | |
| 859 int32_t endTime; | |
| 860 int32_t startYear; // the year these DST rules took effect | |
| 861 int32_t rawOffset; // the TimeZone's raw GMT offset | |
| 862 UBool useDaylight; // flag indicating whether this TimeZone uses DST | |
| 863 static const int8_t STATICMONTHLENGTH[12]; // lengths of the months | |
| 864 EMode startMode, endMode; // flags indicating what kind of rules the DST r
ules are | |
| 865 | |
| 866 /** | |
| 867 * A positive value indicating the amount of time saved during DST in ms. | |
| 868 * Typically one hour; sometimes 30 minutes. | |
| 869 */ | |
| 870 int32_t dstSavings; | |
| 871 | |
| 872 /* Private for BasicTimeZone implementation */ | |
| 873 void initTransitionRules(UErrorCode& status); | |
| 874 void clearTransitionRules(void); | |
| 875 void deleteTransitionRules(void); | |
| 876 UBool transitionRulesInitialized; | |
| 877 InitialTimeZoneRule* initialRule; | |
| 878 TimeZoneTransition* firstTransition; | |
| 879 AnnualTimeZoneRule* stdRule; | |
| 880 AnnualTimeZoneRule* dstRule; | |
| 881 }; | |
| 882 | |
| 883 inline void SimpleTimeZone::setStartRule(int32_t month, int32_t dayOfWeekInMonth
, | |
| 884 int32_t dayOfWeek, | |
| 885 int32_t time, UErrorCode& status) { | |
| 886 setStartRule(month, dayOfWeekInMonth, dayOfWeek, time, WALL_TIME, status); | |
| 887 } | |
| 888 | |
| 889 inline void SimpleTimeZone::setStartRule(int32_t month, int32_t dayOfMonth, | |
| 890 int32_t time, | |
| 891 UErrorCode& status) { | |
| 892 setStartRule(month, dayOfMonth, time, WALL_TIME, status); | |
| 893 } | |
| 894 | |
| 895 inline void SimpleTimeZone::setStartRule(int32_t month, int32_t dayOfMonth, | |
| 896 int32_t dayOfWeek, | |
| 897 int32_t time, UBool after, UErrorCode&
status) { | |
| 898 setStartRule(month, dayOfMonth, dayOfWeek, time, WALL_TIME, after, status); | |
| 899 } | |
| 900 | |
| 901 inline void SimpleTimeZone::setEndRule(int32_t month, int32_t dayOfWeekInMonth, | |
| 902 int32_t dayOfWeek, | |
| 903 int32_t time, UErrorCode& status) { | |
| 904 setEndRule(month, dayOfWeekInMonth, dayOfWeek, time, WALL_TIME, status); | |
| 905 } | |
| 906 | |
| 907 inline void SimpleTimeZone::setEndRule(int32_t month, int32_t dayOfMonth, | |
| 908 int32_t time, UErrorCode& status) { | |
| 909 setEndRule(month, dayOfMonth, time, WALL_TIME, status); | |
| 910 } | |
| 911 | |
| 912 inline void SimpleTimeZone::setEndRule(int32_t month, int32_t dayOfMonth, int32_
t dayOfWeek, | |
| 913 int32_t time, UBool after, UErrorCode& st
atus) { | |
| 914 setEndRule(month, dayOfMonth, dayOfWeek, time, WALL_TIME, after, status); | |
| 915 } | |
| 916 | |
| 917 inline void | |
| 918 SimpleTimeZone::getOffset(UDate date, UBool local, int32_t& rawOffsetRef, | |
| 919 int32_t& dstOffsetRef, UErrorCode& ec) const { | |
| 920 TimeZone::getOffset(date, local, rawOffsetRef, dstOffsetRef, ec); | |
| 921 } | |
| 922 | |
| 923 U_NAMESPACE_END | |
| 924 | |
| 925 #endif /* #if !UCONFIG_NO_FORMATTING */ | |
| 926 | |
| 927 #endif // _SIMPLETZ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 19417002:
Move ICU header part 2 (Closed)
Base URL: svn://chrome-svn/chrome/trunk/deps/third_party/icu46/