| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright (C) 1997-2009, International Business Machines Corporation and other
s. | |
| 3 * All Rights Reserved. | |
| 4 ******************************************************************************** | |
| 5 * | |
| 6 * File GREGOCAL.H | |
| 7 * | |
| 8 * Modification History: | |
| 9 * | |
| 10 * Date Name Description | |
| 11 * 04/22/97 aliu Overhauled header. | |
| 12 * 07/28/98 stephen Sync with JDK 1.2 | |
| 13 * 09/04/98 stephen Re-sync with JDK 8/31 putback | |
| 14 * 09/14/98 stephen Changed type of kOneDay, kOneWeek to double. | |
| 15 * Fixed bug in roll() | |
| 16 * 10/15/99 aliu Fixed j31, incorrect WEEK_OF_YEAR computation. | |
| 17 * Added documentation of WEEK_OF_YEAR computation. | |
| 18 * 10/15/99 aliu Fixed j32, cannot set date to Feb 29 2000 AD. | |
| 19 * {JDK bug 4210209 4209272} | |
| 20 * 11/07/2003 srl Update, clean up documentation. | |
| 21 ******************************************************************************** | |
| 22 */ | |
| 23 | |
| 24 #ifndef GREGOCAL_H | |
| 25 #define GREGOCAL_H | |
| 26 | |
| 27 #include "unicode/utypes.h" | |
| 28 | |
| 29 #if !UCONFIG_NO_FORMATTING | |
| 30 | |
| 31 #include "unicode/calendar.h" | |
| 32 | |
| 33 /** | |
| 34 * \file | |
| 35 * \brief C++ API: Concrete class which provides the standard calendar. | |
| 36 */ | |
| 37 | |
| 38 U_NAMESPACE_BEGIN | |
| 39 | |
| 40 /** | |
| 41 * Concrete class which provides the standard calendar used by most of the world
. | |
| 42 * <P> | |
| 43 * The standard (Gregorian) calendar has 2 eras, BC and AD. | |
| 44 * <P> | |
| 45 * This implementation handles a single discontinuity, which corresponds by defa
ult to | |
| 46 * the date the Gregorian calendar was originally instituted (October 15, 1582).
Not all | |
| 47 * countries adopted the Gregorian calendar then, so this cutover date may be ch
anged by | |
| 48 * the caller. | |
| 49 * <P> | |
| 50 * Prior to the institution of the Gregorian Calendar, New Year's Day was March
25. To | |
| 51 * avoid confusion, this Calendar always uses January 1. A manual adjustment may
be made | |
| 52 * if desired for dates that are prior to the Gregorian changeover and which fal
l | |
| 53 * between January 1 and March 24. | |
| 54 * | |
| 55 * <p>Values calculated for the <code>WEEK_OF_YEAR</code> field range from 1 to | |
| 56 * 53. Week 1 for a year is the first week that contains at least | |
| 57 * <code>getMinimalDaysInFirstWeek()</code> days from that year. It thus | |
| 58 * depends on the values of <code>getMinimalDaysInFirstWeek()</code>, | |
| 59 * <code>getFirstDayOfWeek()</code>, and the day of the week of January 1. | |
| 60 * Weeks between week 1 of one year and week 1 of the following year are | |
| 61 * numbered sequentially from 2 to 52 or 53 (as needed). | |
| 62 * | |
| 63 * <p>For example, January 1, 1998 was a Thursday. If | |
| 64 * <code>getFirstDayOfWeek()</code> is <code>MONDAY</code> and | |
| 65 * <code>getMinimalDaysInFirstWeek()</code> is 4 (these are the values | |
| 66 * reflecting ISO 8601 and many national standards), then week 1 of 1998 starts | |
| 67 * on December 29, 1997, and ends on January 4, 1998. If, however, | |
| 68 * <code>getFirstDayOfWeek()</code> is <code>SUNDAY</code>, then week 1 of 1998 | |
| 69 * starts on January 4, 1998, and ends on January 10, 1998; the first three days | |
| 70 * of 1998 then are part of week 53 of 1997. | |
| 71 * | |
| 72 * <p>Example for using GregorianCalendar: | |
| 73 * <pre> | |
| 74 * \code | |
| 75 * // get the supported ids for GMT-08:00 (Pacific Standard Time) | |
| 76 * UErrorCode success = U_ZERO_ERROR; | |
| 77 * const StringEnumeration *ids = TimeZone::createEnumeration(-8 * 60 * 60 *
1000); | |
| 78 * // if no ids were returned, something is wrong. get out. | |
| 79 * if (ids == 0 || ids->count(success) == 0) { | |
| 80 * return; | |
| 81 * } | |
| 82 * | |
| 83 * // begin output | |
| 84 * cout << "Current Time" << endl; | |
| 85 * | |
| 86 * // create a Pacific Standard Time time zone | |
| 87 * SimpleTimeZone* pdt = new SimpleTimeZone(-8 * 60 * 60 * 1000, ids->unext(
NULL, success))); | |
| 88 * | |
| 89 * // set up rules for daylight savings time | |
| 90 * pdt->setStartRule(UCAL_MARCH, 1, UCAL_SUNDAY, 2 * 60 * 60 * 1000); | |
| 91 * pdt->setEndRule(UCAL_NOVEMBER, 2, UCAL_SUNDAY, 2 * 60 * 60 * 1000); | |
| 92 * | |
| 93 * // create a GregorianCalendar with the Pacific Daylight time zone | |
| 94 * // and the current date and time | |
| 95 * Calendar* calendar = new GregorianCalendar( pdt, success ); | |
| 96 * | |
| 97 * // print out a bunch of interesting things | |
| 98 * cout << "ERA: " << calendar->get( UCAL_ERA, success ) << endl; | |
| 99 * cout << "YEAR: " << calendar->get( UCAL_YEAR, success ) << endl; | |
| 100 * cout << "MONTH: " << calendar->get( UCAL_MONTH, success ) << endl; | |
| 101 * cout << "WEEK_OF_YEAR: " << calendar->get( UCAL_WEEK_OF_YEAR, success ) <
< endl; | |
| 102 * cout << "WEEK_OF_MONTH: " << calendar->get( UCAL_WEEK_OF_MONTH, success )
<< endl; | |
| 103 * cout << "DATE: " << calendar->get( UCAL_DATE, success ) << endl; | |
| 104 * cout << "DAY_OF_MONTH: " << calendar->get( UCAL_DAY_OF_MONTH, success ) <
< endl; | |
| 105 * cout << "DAY_OF_YEAR: " << calendar->get( UCAL_DAY_OF_YEAR, success ) <<
endl; | |
| 106 * cout << "DAY_OF_WEEK: " << calendar->get( UCAL_DAY_OF_WEEK, success ) <<
endl; | |
| 107 * cout << "DAY_OF_WEEK_IN_MONTH: " << calendar->get( UCAL_DAY_OF_WEEK_IN_MO
NTH, success ) << endl; | |
| 108 * cout << "AM_PM: " << calendar->get( UCAL_AM_PM, success ) << endl; | |
| 109 * cout << "HOUR: " << calendar->get( UCAL_HOUR, success ) << endl; | |
| 110 * cout << "HOUR_OF_DAY: " << calendar->get( UCAL_HOUR_OF_DAY, success ) <<
endl; | |
| 111 * cout << "MINUTE: " << calendar->get( UCAL_MINUTE, success ) << endl; | |
| 112 * cout << "SECOND: " << calendar->get( UCAL_SECOND, success ) << endl; | |
| 113 * cout << "MILLISECOND: " << calendar->get( UCAL_MILLISECOND, success ) <<
endl; | |
| 114 * cout << "ZONE_OFFSET: " << (calendar->get( UCAL_ZONE_OFFSET, success )/(6
0*60*1000)) << endl; | |
| 115 * cout << "DST_OFFSET: " << (calendar->get( UCAL_DST_OFFSET, success )/(60*
60*1000)) << endl; | |
| 116 * | |
| 117 * cout << "Current Time, with hour reset to 3" << endl; | |
| 118 * calendar->clear(UCAL_HOUR_OF_DAY); // so doesn't override | |
| 119 * calendar->set(UCAL_HOUR, 3); | |
| 120 * cout << "ERA: " << calendar->get( UCAL_ERA, success ) << endl; | |
| 121 * cout << "YEAR: " << calendar->get( UCAL_YEAR, success ) << endl; | |
| 122 * cout << "MONTH: " << calendar->get( UCAL_MONTH, success ) << endl; | |
| 123 * cout << "WEEK_OF_YEAR: " << calendar->get( UCAL_WEEK_OF_YEAR, success ) <
< endl; | |
| 124 * cout << "WEEK_OF_MONTH: " << calendar->get( UCAL_WEEK_OF_MONTH, success )
<< endl; | |
| 125 * cout << "DATE: " << calendar->get( UCAL_DATE, success ) << endl; | |
| 126 * cout << "DAY_OF_MONTH: " << calendar->get( UCAL_DAY_OF_MONTH, success ) <
< endl; | |
| 127 * cout << "DAY_OF_YEAR: " << calendar->get( UCAL_DAY_OF_YEAR, success ) <<
endl; | |
| 128 * cout << "DAY_OF_WEEK: " << calendar->get( UCAL_DAY_OF_WEEK, success ) <<
endl; | |
| 129 * cout << "DAY_OF_WEEK_IN_MONTH: " << calendar->get( UCAL_DAY_OF_WEEK_IN_MO
NTH, success ) << endl; | |
| 130 * cout << "AM_PM: " << calendar->get( UCAL_AM_PM, success ) << endl; | |
| 131 * cout << "HOUR: " << calendar->get( UCAL_HOUR, success ) << endl; | |
| 132 * cout << "HOUR_OF_DAY: " << calendar->get( UCAL_HOUR_OF_DAY, success ) <<
endl; | |
| 133 * cout << "MINUTE: " << calendar->get( UCAL_MINUTE, success ) << endl; | |
| 134 * cout << "SECOND: " << calendar->get( UCAL_SECOND, success ) << endl; | |
| 135 * cout << "MILLISECOND: " << calendar->get( UCAL_MILLISECOND, success ) <<
endl; | |
| 136 * cout << "ZONE_OFFSET: " << (calendar->get( UCAL_ZONE_OFFSET, success )/(6
0*60*1000)) << endl; // in hours | |
| 137 * cout << "DST_OFFSET: " << (calendar->get( UCAL_DST_OFFSET, success )/(60*
60*1000)) << endl; // in hours | |
| 138 * | |
| 139 * if (U_FAILURE(success)) { | |
| 140 * cout << "An error occured. success=" << u_errorName(success) << endl; | |
| 141 * } | |
| 142 * | |
| 143 * delete ids; | |
| 144 * delete calendar; // also deletes pdt | |
| 145 * \endcode | |
| 146 * </pre> | |
| 147 * @stable ICU 2.0 | |
| 148 */ | |
| 149 class U_I18N_API GregorianCalendar: public Calendar { | |
| 150 public: | |
| 151 | |
| 152 /** | |
| 153 * Useful constants for GregorianCalendar and TimeZone. | |
| 154 * @stable ICU 2.0 | |
| 155 */ | |
| 156 enum EEras { | |
| 157 BC, | |
| 158 AD | |
| 159 }; | |
| 160 | |
| 161 /** | |
| 162 * Constructs a default GregorianCalendar using the current time in the defa
ult time | |
| 163 * zone with the default locale. | |
| 164 * | |
| 165 * @param success Indicates the status of GregorianCalendar object construc
tion. | |
| 166 * Returns U_ZERO_ERROR if constructed successfully. | |
| 167 * @stable ICU 2.0 | |
| 168 */ | |
| 169 GregorianCalendar(UErrorCode& success); | |
| 170 | |
| 171 /** | |
| 172 * Constructs a GregorianCalendar based on the current time in the given tim
e zone | |
| 173 * with the default locale. Clients are no longer responsible for deleting t
he given | |
| 174 * time zone object after it's adopted. | |
| 175 * | |
| 176 * @param zoneToAdopt The given timezone. | |
| 177 * @param success Indicates the status of GregorianCalendar object construc
tion. | |
| 178 * Returns U_ZERO_ERROR if constructed successfully. | |
| 179 * @stable ICU 2.0 | |
| 180 */ | |
| 181 GregorianCalendar(TimeZone* zoneToAdopt, UErrorCode& success); | |
| 182 | |
| 183 /** | |
| 184 * Constructs a GregorianCalendar based on the current time in the given tim
e zone | |
| 185 * with the default locale. | |
| 186 * | |
| 187 * @param zone The given timezone. | |
| 188 * @param success Indicates the status of GregorianCalendar object construc
tion. | |
| 189 * Returns U_ZERO_ERROR if constructed successfully. | |
| 190 * @stable ICU 2.0 | |
| 191 */ | |
| 192 GregorianCalendar(const TimeZone& zone, UErrorCode& success); | |
| 193 | |
| 194 /** | |
| 195 * Constructs a GregorianCalendar based on the current time in the default t
ime zone | |
| 196 * with the given locale. | |
| 197 * | |
| 198 * @param aLocale The given locale. | |
| 199 * @param success Indicates the status of GregorianCalendar object construc
tion. | |
| 200 * Returns U_ZERO_ERROR if constructed successfully. | |
| 201 * @stable ICU 2.0 | |
| 202 */ | |
| 203 GregorianCalendar(const Locale& aLocale, UErrorCode& success); | |
| 204 | |
| 205 /** | |
| 206 * Constructs a GregorianCalendar based on the current time in the given tim
e zone | |
| 207 * with the given locale. Clients are no longer responsible for deleting the
given | |
| 208 * time zone object after it's adopted. | |
| 209 * | |
| 210 * @param zoneToAdopt The given timezone. | |
| 211 * @param aLocale The given locale. | |
| 212 * @param success Indicates the status of GregorianCalendar object construc
tion. | |
| 213 * Returns U_ZERO_ERROR if constructed successfully. | |
| 214 * @stable ICU 2.0 | |
| 215 */ | |
| 216 GregorianCalendar(TimeZone* zoneToAdopt, const Locale& aLocale, UErrorCode&
success); | |
| 217 | |
| 218 /** | |
| 219 * Constructs a GregorianCalendar based on the current time in the given tim
e zone | |
| 220 * with the given locale. | |
| 221 * | |
| 222 * @param zone The given timezone. | |
| 223 * @param aLocale The given locale. | |
| 224 * @param success Indicates the status of GregorianCalendar object construc
tion. | |
| 225 * Returns U_ZERO_ERROR if constructed successfully. | |
| 226 * @stable ICU 2.0 | |
| 227 */ | |
| 228 GregorianCalendar(const TimeZone& zone, const Locale& aLocale, UErrorCode& s
uccess); | |
| 229 | |
| 230 /** | |
| 231 * Constructs a GregorianCalendar with the given AD date set in the default
time | |
| 232 * zone with the default locale. | |
| 233 * | |
| 234 * @param year The value used to set the YEAR time field in the calendar
. | |
| 235 * @param month The value used to set the MONTH time field in the calenda
r. Month | |
| 236 * value is 0-based. e.g., 0 for January. | |
| 237 * @param date The value used to set the DATE time field in the calendar
. | |
| 238 * @param success Indicates the status of GregorianCalendar object construc
tion. | |
| 239 * Returns U_ZERO_ERROR if constructed successfully. | |
| 240 * @stable ICU 2.0 | |
| 241 */ | |
| 242 GregorianCalendar(int32_t year, int32_t month, int32_t date, UErrorCode& suc
cess); | |
| 243 | |
| 244 /** | |
| 245 * Constructs a GregorianCalendar with the given AD date and time set for th
e | |
| 246 * default time zone with the default locale. | |
| 247 * | |
| 248 * @param year The value used to set the YEAR time field in the calendar
. | |
| 249 * @param month The value used to set the MONTH time field in the calenda
r. Month | |
| 250 * value is 0-based. e.g., 0 for January. | |
| 251 * @param date The value used to set the DATE time field in the calendar
. | |
| 252 * @param hour The value used to set the HOUR_OF_DAY time field in the c
alendar. | |
| 253 * @param minute The value used to set the MINUTE time field in the calend
ar. | |
| 254 * @param success Indicates the status of GregorianCalendar object construc
tion. | |
| 255 * Returns U_ZERO_ERROR if constructed successfully. | |
| 256 * @stable ICU 2.0 | |
| 257 */ | |
| 258 GregorianCalendar(int32_t year, int32_t month, int32_t date, int32_t hour, i
nt32_t minute, UErrorCode& success); | |
| 259 | |
| 260 /** | |
| 261 * Constructs a GregorianCalendar with the given AD date and time set for th
e | |
| 262 * default time zone with the default locale. | |
| 263 * | |
| 264 * @param year The value used to set the YEAR time field in the calendar
. | |
| 265 * @param month The value used to set the MONTH time field in the calenda
r. Month | |
| 266 * value is 0-based. e.g., 0 for January. | |
| 267 * @param date The value used to set the DATE time field in the calendar
. | |
| 268 * @param hour The value used to set the HOUR_OF_DAY time field in the c
alendar. | |
| 269 * @param minute The value used to set the MINUTE time field in the calend
ar. | |
| 270 * @param second The value used to set the SECOND time field in the calend
ar. | |
| 271 * @param success Indicates the status of GregorianCalendar object construc
tion. | |
| 272 * Returns U_ZERO_ERROR if constructed successfully. | |
| 273 * @stable ICU 2.0 | |
| 274 */ | |
| 275 GregorianCalendar(int32_t year, int32_t month, int32_t date, int32_t hour, i
nt32_t minute, int32_t second, UErrorCode& success); | |
| 276 | |
| 277 /** | |
| 278 * Destructor | |
| 279 * @stable ICU 2.0 | |
| 280 */ | |
| 281 virtual ~GregorianCalendar(); | |
| 282 | |
| 283 /** | |
| 284 * Copy constructor | |
| 285 * @param source the object to be copied. | |
| 286 * @stable ICU 2.0 | |
| 287 */ | |
| 288 GregorianCalendar(const GregorianCalendar& source); | |
| 289 | |
| 290 /** | |
| 291 * Default assignment operator | |
| 292 * @param right the object to be copied. | |
| 293 * @stable ICU 2.0 | |
| 294 */ | |
| 295 GregorianCalendar& operator=(const GregorianCalendar& right); | |
| 296 | |
| 297 /** | |
| 298 * Create and return a polymorphic copy of this calendar. | |
| 299 * @return return a polymorphic copy of this calendar. | |
| 300 * @stable ICU 2.0 | |
| 301 */ | |
| 302 virtual Calendar* clone(void) const; | |
| 303 | |
| 304 /** | |
| 305 * Sets the GregorianCalendar change date. This is the point when the switch
from | |
| 306 * Julian dates to Gregorian dates occurred. Default is 00:00:00 local time,
October | |
| 307 * 15, 1582. Previous to this time and date will be Julian dates. | |
| 308 * | |
| 309 * @param date The given Gregorian cutover date. | |
| 310 * @param success Output param set to success/failure code on exit. | |
| 311 * @stable ICU 2.0 | |
| 312 */ | |
| 313 void setGregorianChange(UDate date, UErrorCode& success); | |
| 314 | |
| 315 /** | |
| 316 * Gets the Gregorian Calendar change date. This is the point when the switc
h from | |
| 317 * Julian dates to Gregorian dates occurred. Default is 00:00:00 local time,
October | |
| 318 * 15, 1582. Previous to this time and date will be Julian dates. | |
| 319 * | |
| 320 * @return The Gregorian cutover time for this calendar. | |
| 321 * @stable ICU 2.0 | |
| 322 */ | |
| 323 UDate getGregorianChange(void) const; | |
| 324 | |
| 325 /** | |
| 326 * Return true if the given year is a leap year. Determination of whether a
year is | |
| 327 * a leap year is actually very complicated. We do something crude and mostl
y | |
| 328 * correct here, but for a real determination you need a lot of contextual | |
| 329 * information. For example, in Sweden, the change from Julian to Gregorian
happened | |
| 330 * in a complex way resulting in missed leap years and double leap years bet
ween | |
| 331 * 1700 and 1753. Another example is that after the start of the Julian cale
ndar in | |
| 332 * 45 B.C., the leap years did not regularize until 8 A.D. This method ignor
es these | |
| 333 * quirks, and pays attention only to the Julian onset date and the Gregoria
n | |
| 334 * cutover (which can be changed). | |
| 335 * | |
| 336 * @param year The given year. | |
| 337 * @return True if the given year is a leap year; false otherwise. | |
| 338 * @stable ICU 2.0 | |
| 339 */ | |
| 340 UBool isLeapYear(int32_t year) const; | |
| 341 | |
| 342 /** | |
| 343 * Returns TRUE if the given Calendar object is equivalent to this | |
| 344 * one. Calendar override. | |
| 345 * | |
| 346 * @param other the Calendar to be compared with this Calendar | |
| 347 * @stable ICU 2.4 | |
| 348 */ | |
| 349 virtual UBool isEquivalentTo(const Calendar& other) const; | |
| 350 | |
| 351 /** | |
| 352 * (Overrides Calendar) Rolls up or down by the given amount in the specifie
d field. | |
| 353 * For more information, see the documentation for Calendar::roll(). | |
| 354 * | |
| 355 * @param field The time field. | |
| 356 * @param amount Indicates amount to roll. | |
| 357 * @param status Output param set to success/failure code on exit. If any v
alue | |
| 358 * previously set in the time field is invalid, this will be
set to | |
| 359 * an error status. | |
| 360 * @deprecated ICU 2.6. Use roll(UCalendarDateFields field, int32_t amount,
UErrorCode& status) instead. | |
| 361 */ | |
| 362 virtual void roll(EDateFields field, int32_t amount, UErrorCode& status); | |
| 363 | |
| 364 /** | |
| 365 * (Overrides Calendar) Rolls up or down by the given amount in the specifie
d field. | |
| 366 * For more information, see the documentation for Calendar::roll(). | |
| 367 * | |
| 368 * @param field The time field. | |
| 369 * @param amount Indicates amount to roll. | |
| 370 * @param status Output param set to success/failure code on exit. If any v
alue | |
| 371 * previously set in the time field is invalid, this will be
set to | |
| 372 * an error status. | |
| 373 * @stable ICU 2.6. | |
| 374 */ | |
| 375 virtual void roll(UCalendarDateFields field, int32_t amount, UErrorCode& sta
tus); | |
| 376 | |
| 377 /** | |
| 378 * Return the minimum value that this field could have, given the current da
te. | |
| 379 * For the Gregorian calendar, this is the same as getMinimum() and getGreat
estMinimum(). | |
| 380 * @param field the time field. | |
| 381 * @return the minimum value that this field could have, given the c
urrent date. | |
| 382 * @deprecated ICU 2.6. Use getActualMinimum(UCalendarDateFields field) inst
ead. | |
| 383 */ | |
| 384 int32_t getActualMinimum(EDateFields field) const; | |
| 385 | |
| 386 /** | |
| 387 * Return the minimum value that this field could have, given the current da
te. | |
| 388 * For the Gregorian calendar, this is the same as getMinimum() and getGreat
estMinimum(). | |
| 389 * @param field the time field. | |
| 390 * @param status | |
| 391 * @return the minimum value that this field could have, given the c
urrent date. | |
| 392 * @deprecated ICU 2.6. Use getActualMinimum(UCalendarDateFields field) inst
ead. (Added to ICU 3.0 for signature consistency) | |
| 393 */ | |
| 394 int32_t getActualMinimum(EDateFields field, UErrorCode& status) const; | |
| 395 | |
| 396 /** | |
| 397 * Return the minimum value that this field could have, given the current da
te. | |
| 398 * For the Gregorian calendar, this is the same as getMinimum() and getGreat
estMinimum(). | |
| 399 * @param field the time field. | |
| 400 * @param status error result. | |
| 401 * @return the minimum value that this field could have, given the c
urrent date. | |
| 402 * @stable ICU 3.0 | |
| 403 */ | |
| 404 int32_t getActualMinimum(UCalendarDateFields field, UErrorCode &status) cons
t; | |
| 405 | |
| 406 /** | |
| 407 * Return the maximum value that this field could have, given the current da
te. | |
| 408 * For example, with the date "Feb 3, 1997" and the DAY_OF_MONTH field, the
actual | |
| 409 * maximum would be 28; for "Feb 3, 1996" it s 29. Similarly for a Hebrew c
alendar, | |
| 410 * for some years the actual maximum for MONTH is 12, and for others 13. | |
| 411 * @param field the time field. | |
| 412 * @return the maximum value that this field could have, given the c
urrent date. | |
| 413 * @deprecated ICU 2.6. Use getActualMaximum(UCalendarDateFields field) inst
ead. | |
| 414 */ | |
| 415 int32_t getActualMaximum(EDateFields field) const; | |
| 416 | |
| 417 /** | |
| 418 * Return the maximum value that this field could have, given the current da
te. | |
| 419 * For example, with the date "Feb 3, 1997" and the DAY_OF_MONTH field, the
actual | |
| 420 * maximum would be 28; for "Feb 3, 1996" it s 29. Similarly for a Hebrew c
alendar, | |
| 421 * for some years the actual maximum for MONTH is 12, and for others 13. | |
| 422 * @param field the time field. | |
| 423 * @param status returns any errors that may result from this function cal
l. | |
| 424 * @return the maximum value that this field could have, given the c
urrent date. | |
| 425 * @stable ICU 2.6 | |
| 426 */ | |
| 427 virtual int32_t getActualMaximum(UCalendarDateFields field, UErrorCode& stat
us) const; | |
| 428 | |
| 429 /** | |
| 430 * (Overrides Calendar) Return true if the current date for this Calendar is
in | |
| 431 * Daylight Savings Time. Recognizes DST_OFFSET, if it is set. | |
| 432 * | |
| 433 * @param status Fill-in parameter which receives the status of this operati
on. | |
| 434 * @return True if the current date for this Calendar is in Daylight Savin
gs Time, | |
| 435 * false, otherwise. | |
| 436 * @stable ICU 2.0 | |
| 437 */ | |
| 438 virtual UBool inDaylightTime(UErrorCode& status) const; | |
| 439 | |
| 440 public: | |
| 441 | |
| 442 /** | |
| 443 * Override Calendar Returns a unique class ID POLYMORPHICALLY. Pure virtual | |
| 444 * override. This method is to implement a simple version of RTTI, since not
all C++ | |
| 445 * compilers support genuine RTTI. Polymorphic operator==() and clone() meth
ods call | |
| 446 * this method. | |
| 447 * | |
| 448 * @return The class ID for this object. All objects of a given class have
the | |
| 449 * same class ID. Objects of other classes have different class ID
s. | |
| 450 * @stable ICU 2.0 | |
| 451 */ | |
| 452 virtual UClassID getDynamicClassID(void) const; | |
| 453 | |
| 454 /** | |
| 455 * Return the class ID for this class. This is useful only for comparing to
a return | |
| 456 * value from getDynamicClassID(). For example: | |
| 457 * | |
| 458 * Base* polymorphic_pointer = createPolymorphicObject(); | |
| 459 * if (polymorphic_pointer->getDynamicClassID() == | |
| 460 * Derived::getStaticClassID()) ... | |
| 461 * | |
| 462 * @return The class ID for all objects of this class. | |
| 463 * @stable ICU 2.0 | |
| 464 */ | |
| 465 static UClassID U_EXPORT2 getStaticClassID(void); | |
| 466 | |
| 467 /** | |
| 468 * Get the calendar type, "gregorian", for use in DateFormatSymbols. | |
| 469 * | |
| 470 * @return calendar type | |
| 471 * @internal | |
| 472 */ | |
| 473 virtual const char * getType() const; | |
| 474 | |
| 475 protected: | |
| 476 | |
| 477 /** | |
| 478 * (Overrides Calendar) Converts GMT as milliseconds to time field values. | |
| 479 * @param status Fill-in parameter which receives the status of this operati
on. | |
| 480 * @stable ICU 2.0 | |
| 481 */ | |
| 482 | |
| 483 private: | |
| 484 GregorianCalendar(); // default constructor not implemented | |
| 485 | |
| 486 protected: | |
| 487 /** | |
| 488 * Return the ERA. We need a special method for this because the | |
| 489 * default ERA is AD, but a zero (unset) ERA is BC. | |
| 490 * @return the ERA. | |
| 491 * @internal | |
| 492 */ | |
| 493 virtual int32_t internalGetEra() const; | |
| 494 | |
| 495 /** | |
| 496 * Return the Julian day number of day before the first day of the | |
| 497 * given month in the given extended year. Subclasses should override | |
| 498 * this method to implement their calendar system. | |
| 499 * @param eyear the extended year | |
| 500 * @param month the zero-based month, or 0 if useMonth is false | |
| 501 * @param useMonth if false, compute the day before the first day of | |
| 502 * the given year, otherwise, compute the day before the first day of | |
| 503 * the given month | |
| 504 * @return the Julian day number of the day before the first | |
| 505 * day of the given month and year | |
| 506 * @internal | |
| 507 */ | |
| 508 virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month, | |
| 509 UBool useMonth) const; | |
| 510 | |
| 511 /** | |
| 512 * Subclasses may override this. This method calls | |
| 513 * handleGetMonthLength() to obtain the calendar-specific month | |
| 514 * length. | |
| 515 * @param bestField which field to use to calculate the date | |
| 516 * @return julian day specified by calendar fields. | |
| 517 * @internal | |
| 518 */ | |
| 519 virtual int32_t handleComputeJulianDay(UCalendarDateFields bestField) ; | |
| 520 | |
| 521 /** | |
| 522 * Return the number of days in the given month of the given extended | |
| 523 * year of this calendar system. Subclasses should override this | |
| 524 * method if they can provide a more correct or more efficient | |
| 525 * implementation than the default implementation in Calendar. | |
| 526 * @internal | |
| 527 */ | |
| 528 virtual int32_t handleGetMonthLength(int32_t extendedYear, int32_t month) co
nst; | |
| 529 | |
| 530 /** | |
| 531 * Return the number of days in the given extended year of this | |
| 532 * calendar system. Subclasses should override this method if they can | |
| 533 * provide a more correct or more efficient implementation than the | |
| 534 * default implementation in Calendar. | |
| 535 * @stable ICU 2.0 | |
| 536 */ | |
| 537 virtual int32_t handleGetYearLength(int32_t eyear) const; | |
| 538 | |
| 539 /** | |
| 540 * return the length of the given month. | |
| 541 * @param month the given month. | |
| 542 * @return the length of the given month. | |
| 543 * @internal | |
| 544 */ | |
| 545 virtual int32_t monthLength(int32_t month) const; | |
| 546 | |
| 547 /** | |
| 548 * return the length of the month according to the given year. | |
| 549 * @param month the given month. | |
| 550 * @param year the given year. | |
| 551 * @return the length of the month | |
| 552 * @internal | |
| 553 */ | |
| 554 virtual int32_t monthLength(int32_t month, int32_t year) const; | |
| 555 | |
| 556 /** | |
| 557 * return the length of the given year. | |
| 558 * @param year the given year. | |
| 559 * @return the length of the given year. | |
| 560 * @internal | |
| 561 */ | |
| 562 int32_t yearLength(int32_t year) const; | |
| 563 | |
| 564 /** | |
| 565 * return the length of the year field. | |
| 566 * @return the length of the year field | |
| 567 * @internal | |
| 568 */ | |
| 569 int32_t yearLength(void) const; | |
| 570 | |
| 571 /** | |
| 572 * After adjustments such as add(MONTH), add(YEAR), we don't want the | |
| 573 * month to jump around. E.g., we don't want Jan 31 + 1 month to go to Mar | |
| 574 * 3, we want it to go to Feb 28. Adjustments which might run into this | |
| 575 * problem call this method to retain the proper month. | |
| 576 * @internal | |
| 577 */ | |
| 578 void pinDayOfMonth(void); | |
| 579 | |
| 580 /** | |
| 581 * Return the day number with respect to the epoch. January 1, 1970 (Gregor
ian) | |
| 582 * is day zero. | |
| 583 * @param status Fill-in parameter which receives the status of this operati
on. | |
| 584 * @return the day number with respect to the epoch. | |
| 585 * @internal | |
| 586 */ | |
| 587 virtual UDate getEpochDay(UErrorCode& status); | |
| 588 | |
| 589 /** | |
| 590 * Subclass API for defining limits of different types. | |
| 591 * Subclasses must implement this method to return limits for the | |
| 592 * following fields: | |
| 593 * | |
| 594 * <pre>UCAL_ERA | |
| 595 * UCAL_YEAR | |
| 596 * UCAL_MONTH | |
| 597 * UCAL_WEEK_OF_YEAR | |
| 598 * UCAL_WEEK_OF_MONTH | |
| 599 * UCAL_DATE (DAY_OF_MONTH on Java) | |
| 600 * UCAL_DAY_OF_YEAR | |
| 601 * UCAL_DAY_OF_WEEK_IN_MONTH | |
| 602 * UCAL_YEAR_WOY | |
| 603 * UCAL_EXTENDED_YEAR</pre> | |
| 604 * | |
| 605 * @param field one of the above field numbers | |
| 606 * @param limitType one of <code>MINIMUM</code>, <code>GREATEST_MINIMUM</cod
e>, | |
| 607 * <code>LEAST_MAXIMUM</code>, or <code>MAXIMUM</code> | |
| 608 * @internal | |
| 609 */ | |
| 610 virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitTy
pe) const; | |
| 611 | |
| 612 /** | |
| 613 * Return the extended year defined by the current fields. This will | |
| 614 * use the UCAL_EXTENDED_YEAR field or the UCAL_YEAR and supra-year fields (
such | |
| 615 * as UCAL_ERA) specific to the calendar system, depending on which set of | |
| 616 * fields is newer. | |
| 617 * @return the extended year | |
| 618 * @internal | |
| 619 */ | |
| 620 virtual int32_t handleGetExtendedYear(); | |
| 621 | |
| 622 /** | |
| 623 * Subclasses may override this to convert from week fields | |
| 624 * (YEAR_WOY and WEEK_OF_YEAR) to an extended year in the case | |
| 625 * where YEAR, EXTENDED_YEAR are not set. | |
| 626 * The Gregorian implementation assumes a yearWoy in gregorian format, accor
ding to the current era. | |
| 627 * @return the extended year, UCAL_EXTENDED_YEAR | |
| 628 * @internal | |
| 629 */ | |
| 630 virtual int32_t handleGetExtendedYearFromWeekFields(int32_t yearWoy, int32_t
woy); | |
| 631 | |
| 632 | |
| 633 /** | |
| 634 * Subclasses may override this method to compute several fields | |
| 635 * specific to each calendar system. These are: | |
| 636 * | |
| 637 * <ul><li>ERA | |
| 638 * <li>YEAR | |
| 639 * <li>MONTH | |
| 640 * <li>DAY_OF_MONTH | |
| 641 * <li>DAY_OF_YEAR | |
| 642 * <li>EXTENDED_YEAR</ul> | |
| 643 * | |
| 644 * <p>The GregorianCalendar implementation implements | |
| 645 * a calendar with the specified Julian/Gregorian cutover date. | |
| 646 * @internal | |
| 647 */ | |
| 648 virtual void handleComputeFields(int32_t julianDay, UErrorCode &status); | |
| 649 | |
| 650 private: | |
| 651 /** | |
| 652 * Compute the julian day number of the given year. | |
| 653 * @param isGregorian if true, using Gregorian calendar, otherwise using
Julian calendar | |
| 654 * @param year the given year. | |
| 655 * @param isLeap true if the year is a leap year. | |
| 656 * @return | |
| 657 */ | |
| 658 static double computeJulianDayOfYear(UBool isGregorian, int32_t year, | |
| 659 UBool& isLeap); | |
| 660 | |
| 661 /** | |
| 662 * Validates the values of the set time fields. True if they're all valid. | |
| 663 * @return True if the set time fields are all valid. | |
| 664 */ | |
| 665 UBool validateFields(void) const; | |
| 666 | |
| 667 /** | |
| 668 * Validates the value of the given time field. True if it's valid. | |
| 669 */ | |
| 670 UBool boundsCheck(int32_t value, UCalendarDateFields field) const; | |
| 671 | |
| 672 /** | |
| 673 * Return the pseudo-time-stamp for two fields, given their | |
| 674 * individual pseudo-time-stamps. If either of the fields | |
| 675 * is unset, then the aggregate is unset. Otherwise, the | |
| 676 * aggregate is the later of the two stamps. | |
| 677 * @param stamp_a One given field. | |
| 678 * @param stamp_b Another given field. | |
| 679 * @return the pseudo-time-stamp for two fields | |
| 680 */ | |
| 681 int32_t aggregateStamp(int32_t stamp_a, int32_t stamp_b); | |
| 682 | |
| 683 /** | |
| 684 * The point at which the Gregorian calendar rules are used, measured in | |
| 685 * milliseconds from the standard epoch. Default is October 15, 1582 | |
| 686 * (Gregorian) 00:00:00 UTC, that is, October 4, 1582 (Julian) is followed | |
| 687 * by October 15, 1582 (Gregorian). This corresponds to Julian day number | |
| 688 * 2299161. This is measured from the standard epoch, not in Julian Days. | |
| 689 * @internal | |
| 690 */ | |
| 691 UDate fGregorianCutover; | |
| 692 | |
| 693 /** | |
| 694 * Julian day number of the Gregorian cutover | |
| 695 */ | |
| 696 int32_t fCutoverJulianDay; | |
| 697 | |
| 698 /** | |
| 699 * Midnight, local time (using this Calendar's TimeZone) at or before the | |
| 700 * gregorianCutover. This is a pure date value with no time of day or | |
| 701 * timezone component. | |
| 702 */ | |
| 703 UDate fNormalizedGregorianCutover;// = gregorianCutover; | |
| 704 | |
| 705 /** | |
| 706 * The year of the gregorianCutover, with 0 representing | |
| 707 * 1 BC, -1 representing 2 BC, etc. | |
| 708 */ | |
| 709 int32_t fGregorianCutoverYear;// = 1582; | |
| 710 | |
| 711 /** | |
| 712 * The year of the gregorianCutover, with 0 representing | |
| 713 * 1 BC, -1 representing 2 BC, etc. | |
| 714 */ | |
| 715 int32_t fGregorianCutoverJulianDay;// = 2299161; | |
| 716 | |
| 717 /** | |
| 718 * Converts time as milliseconds to Julian date. The Julian date used here i
s not a | |
| 719 * true Julian date, since it is measured from midnight, not noon. | |
| 720 * | |
| 721 * @param millis The given milliseconds. | |
| 722 * @return The Julian date number. | |
| 723 */ | |
| 724 static double millisToJulianDay(UDate millis); | |
| 725 | |
| 726 /** | |
| 727 * Converts Julian date to time as milliseconds. The Julian date used here i
s not a | |
| 728 * true Julian date, since it is measured from midnight, not noon. | |
| 729 * | |
| 730 * @param julian The given Julian date number. | |
| 731 * @return Time as milliseconds. | |
| 732 */ | |
| 733 static UDate julianDayToMillis(double julian); | |
| 734 | |
| 735 /** | |
| 736 * Used by handleComputeJulianDay() and handleComputeMonthStart(). | |
| 737 * Temporary field indicating whether the calendar is currently Gregorian as
opposed to Julian. | |
| 738 */ | |
| 739 UBool fIsGregorian; | |
| 740 | |
| 741 /** | |
| 742 * Used by handleComputeJulianDay() and handleComputeMonthStart(). | |
| 743 * Temporary field indicating that the sense of the gregorian cutover should
be inverted | |
| 744 * to handle certain calculations on and around the cutover date. | |
| 745 */ | |
| 746 UBool fInvertGregorian; | |
| 747 | |
| 748 | |
| 749 public: // internal implementation | |
| 750 | |
| 751 /** | |
| 752 * @internal | |
| 753 * @return TRUE if this calendar has the notion of a default century | |
| 754 */ | |
| 755 virtual UBool haveDefaultCentury() const; | |
| 756 | |
| 757 /** | |
| 758 * @internal | |
| 759 * @return the start of the default century | |
| 760 */ | |
| 761 virtual UDate defaultCenturyStart() const; | |
| 762 | |
| 763 /** | |
| 764 * @internal | |
| 765 * @return the beginning year of the default century | |
| 766 */ | |
| 767 virtual int32_t defaultCenturyStartYear() const; | |
| 768 | |
| 769 private: | |
| 770 /** | |
| 771 * The system maintains a static default century start date. This is initia
lized | |
| 772 * the first time it is used. Before then, it is set to SYSTEM_DEFAULT_CENT
URY to | |
| 773 * indicate an uninitialized state. Once the system default century date an
d year | |
| 774 * are set, they do not change. | |
| 775 */ | |
| 776 static UDate fgSystemDefaultCenturyStart; | |
| 777 | |
| 778 /** | |
| 779 * See documentation for systemDefaultCenturyStart. | |
| 780 */ | |
| 781 static int32_t fgSystemDefaultCenturyStartYear; | |
| 782 | |
| 783 /** | |
| 784 * Default value that indicates the defaultCenturyStartYear is unitialized | |
| 785 */ | |
| 786 static const int32_t fgSystemDefaultCenturyYear; | |
| 787 | |
| 788 /** | |
| 789 * Default value that indicates the UDate of the beginning of the system def
ault century | |
| 790 */ | |
| 791 static const UDate fgSystemDefaultCentury; | |
| 792 | |
| 793 /** | |
| 794 * Returns the beginning date of the 100-year window that dates with 2-digit
years | |
| 795 * are considered to fall within. | |
| 796 * @return the beginning date of the 100-year window that dates with 2-di
git years | |
| 797 * are considered to fall within. | |
| 798 */ | |
| 799 UDate internalGetDefaultCenturyStart(void) const; | |
| 800 | |
| 801 /** | |
| 802 * Returns the first year of the 100-year window that dates with 2-digit yea
rs | |
| 803 * are considered to fall within. | |
| 804 * @return the first year of the 100-year window that dates with 2-digit
years | |
| 805 * are considered to fall within. | |
| 806 */ | |
| 807 int32_t internalGetDefaultCenturyStartYear(void) const; | |
| 808 | |
| 809 /** | |
| 810 * Initializes the 100-year window that dates with 2-digit years are conside
red | |
| 811 * to fall within so that its start date is 80 years before the current time
. | |
| 812 */ | |
| 813 static void initializeSystemDefaultCentury(void); | |
| 814 | |
| 815 }; | |
| 816 | |
| 817 U_NAMESPACE_END | |
| 818 | |
| 819 #endif /* #if !UCONFIG_NO_FORMATTING */ | |
| 820 | |
| 821 #endif // _GREGOCAL | |
| 822 //eof | |
| 823 | |
| 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