| /* |
| ******************************************************************************* |
| * Copyright (C) 1997-1999, International Business Machines Corporation and * |
| * others. All Rights Reserved. * |
| ******************************************************************************* |
| * |
| * File GREGOCAL.CPP |
| * |
| * Modification History: |
| * |
| * Date Name Description |
| * 02/05/97 clhuang Creation. |
| * 03/28/97 aliu Made highly questionable fix to computeFields to |
| * handle DST correctly. |
| * 04/22/97 aliu Cleaned up code drastically. Added monthLength(). |
| * Finished unimplemented parts of computeTime() for |
| * week-based date determination. Removed quetionable |
| * fix and wrote correct fix for computeFields() and |
| * daylight time handling. Rewrote inDaylightTime() |
| * and computeFields() to handle sensitive Daylight to |
| * Standard time transitions correctly. |
| * 05/08/97 aliu Added code review changes. Fixed isLeapYear() to |
| * not cutover. |
| * 08/12/97 aliu Added equivalentTo. Misc other fixes. Updated |
| * add() from Java source. |
| * 07/28/98 stephen Sync up with JDK 1.2 |
| * 09/14/98 stephen Changed type of kOneDay, kOneWeek to double. |
| * Fixed bug in roll() |
| * 10/15/99 aliu Fixed j31, incorrect WEEK_OF_YEAR computation. |
| * 10/15/99 aliu Fixed j32, cannot set date to Feb 29 2000 AD. |
| * {JDK bug 4210209 4209272} |
| * 11/15/99 weiv Added YEAR_WOY and DOW_LOCAL computation |
| * to timeToFields method, updated kMinValues, kMaxValues & kLeastMaxValues |
| * 12/09/99 aliu Fixed j81, calculation errors and roll bugs |
| * in year of cutover. |
| * 01/24/2000 aliu Revised computeJulianDay for YEAR YEAR_WOY WOY. |
| ******************************************************************************** |
| */ |
| |
| #ifndef _GREGOCAL |
| #include "unicode/gregocal.h" |
| #endif |
| |
| // ***************************************************************************** |
| // class GregorianCalendar |
| // ***************************************************************************** |
| |
| |
| const int32_t GregorianCalendar::kJan1_1JulianDay = 1721426; // January 1, year 1 (Gregorian) |
| |
| /** |
| * Note that the Julian date used here is not a true Julian date, since |
| * it is measured from midnight, not noon. This value is the Julian |
| * day number of January 1, 1970 (Gregorian calendar) at noon UTC. [LIU] |
| */ |
| const int32_t GregorianCalendar::kEpochStartAsJulianDay = 2440588; // January 1, 1970 (Gregorian) |
| |
| const int32_t GregorianCalendar::kEpochYear = 1970; |
| |
| const int32_t GregorianCalendar::kNumDays[] |
| = {0,31,59,90,120,151,181,212,243,273,304,334}; // 0-based, for day-in-year |
| const int32_t GregorianCalendar::kLeapNumDays[] |
| = {0,31,60,91,121,152,182,213,244,274,305,335}; // 0-based, for day-in-year |
| const int32_t GregorianCalendar::kMonthLength[] |
| = {31,28,31,30,31,30,31,31,30,31,30,31}; // 0-based |
| const int32_t GregorianCalendar::kLeapMonthLength[] |
| = {31,29,31,30,31,30,31,31,30,31,30,31}; // 0-based |
| |
| // Useful millisecond constants |
| const int32_t GregorianCalendar::kOneSecond = 1000; |
| const int32_t GregorianCalendar::kOneMinute = 60 * kOneSecond; // 60,000 |
| const int32_t GregorianCalendar::kOneHour = 60 * kOneMinute; // 3,600,000 |
| const double GregorianCalendar::kOneDay = 24.0 * kOneHour; // 86,400,000 |
| const double GregorianCalendar::kOneWeek = 7.0 * kOneDay; // 604,800,000 |
| |
| // These numbers are 2^52 - 1, the largest allowable mantissa in a 64-bit double |
| // with a 0 exponent. These are the absolute largest numbers for millis that |
| // this calendar will handle reliably. It will work for larger values, however. |
| // The problem is that, once the exponent is not 0, the calendar will jump. |
| // When translated into a year, LATEST_SUPPORTED_MILLIS corresponds to 144,683 AD |
| // and EARLIEST_SUPPORTED_MILLIS corresponds to 140,742 BC |
| const UDate GregorianCalendar::EARLIEST_SUPPORTED_MILLIS = - 4503599627370495.0; |
| const UDate GregorianCalendar::LATEST_SUPPORTED_MILLIS = 4503599627370495.0; |
| |
| /* |
| * <pre> |
| * Greatest Least |
| * Field name Minimum Minimum Maximum Maximum |
| * ---------- ------- ------- ------- ------- |
| * ERA 0 0 1 1 |
| * YEAR 1 1 140742 144683 |
| * MONTH 0 0 11 11 |
| * WEEK_OF_YEAR 1 1 52 53 |
| * WEEK_OF_MONTH 0 0 4 6 |
| * DAY_OF_MONTH 1 1 28 31 |
| * DAY_OF_YEAR 1 1 365 366 |
| * DAY_OF_WEEK 1 1 7 7 |
| * DAY_OF_WEEK_IN_MONTH -1 -1 4 6 |
| * AM_PM 0 0 1 1 |
| * HOUR 0 0 11 11 |
| * HOUR_OF_DAY 0 0 23 23 |
| * MINUTE 0 0 59 59 |
| * SECOND 0 0 59 59 |
| * MILLISECOND 0 0 999 999 |
| * ZONE_OFFSET -12* -12* 12* 12* |
| * DST_OFFSET 0 0 1* 1* |
| * YEAR_WOY 1 1 140742 144683 |
| * DOW_LOCAL 1 1 7 7 |
| * </pre> |
| * (*) In units of one-hour |
| */ |
| const int32_t GregorianCalendar::kMinValues[] = { |
| 0,1,0,1,0,1,1,1,-1,0,0,0,0,0,0,-12*U_MILLIS_PER_HOUR,0,1,1 |
| }; |
| const int32_t GregorianCalendar::kLeastMaxValues[] = { |
| 1,140742,11,52,4,28,365,7,4,1,11,23,59,59,999,12*U_MILLIS_PER_HOUR,1*U_MILLIS_PER_HOUR,140742,7 |
| }; |
| const int32_t GregorianCalendar::kMaxValues[] = { |
| 1,144683,11,53,6,31,366,7,6,1,11,23,59,59,999,12*U_MILLIS_PER_HOUR,1*U_MILLIS_PER_HOUR, 144683,7 |
| }; |
| |
| char GregorianCalendar::fgClassID = 0; // Value is irrelevant |
| |
| // 00:00:00 UTC, October 15, 1582, expressed in ms from the epoch. |
| // Note that only Italy and other Catholic countries actually |
| // observed this cutover. Most other countries followed in |
| // the next few centuries, some as late as 1928. [LIU] |
| // in Java, -12219292800000L |
| //const UDate GregorianCalendar::kPapalCutover = -12219292800000L; |
| const UDate GregorianCalendar::kPapalCutover = (2299161.0 - kEpochStartAsJulianDay) * kOneDay; |
| |
| // ------------------------------------- |
| |
| GregorianCalendar::GregorianCalendar(UErrorCode& status) |
| : Calendar(TimeZone::createDefault(), Locale::getDefault(), status), |
| fGregorianCutover(kPapalCutover), |
| fNormalizedGregorianCutover(fGregorianCutover), |
| fGregorianCutoverYear(1582) |
| { |
| setTimeInMillis(getNow(), status); |
| } |
| |
| // ------------------------------------- |
| |
| GregorianCalendar::GregorianCalendar(TimeZone* zone, UErrorCode& status) |
| : Calendar(zone, Locale::getDefault(), status), |
| fGregorianCutover(kPapalCutover), |
| fNormalizedGregorianCutover(fGregorianCutover), |
| fGregorianCutoverYear(1582) |
| { |
| setTimeInMillis(getNow(), status); |
| } |
| |
| // ------------------------------------- |
| |
| GregorianCalendar::GregorianCalendar(const TimeZone& zone, UErrorCode& status) |
| : Calendar(zone, Locale::getDefault(), status), |
| fGregorianCutover(kPapalCutover), |
| fNormalizedGregorianCutover(fGregorianCutover), |
| fGregorianCutoverYear(1582) |
| { |
| setTimeInMillis(getNow(), status); |
| } |
| |
| // ------------------------------------- |
| |
| GregorianCalendar::GregorianCalendar(const Locale& aLocale, UErrorCode& status) |
| : Calendar(TimeZone::createDefault(), aLocale, status), |
| fGregorianCutover(kPapalCutover), |
| fNormalizedGregorianCutover(fGregorianCutover), |
| fGregorianCutoverYear(1582) |
| { |
| setTimeInMillis(getNow(), status); |
| } |
| |
| // ------------------------------------- |
| |
| GregorianCalendar::GregorianCalendar(TimeZone* zone, const Locale& aLocale, |
| UErrorCode& status) |
| : Calendar(zone, aLocale, status), |
| fGregorianCutover(kPapalCutover), |
| fNormalizedGregorianCutover(fGregorianCutover), |
| fGregorianCutoverYear(1582) |
| { |
| setTimeInMillis(getNow(), status); |
| } |
| |
| // ------------------------------------- |
| |
| GregorianCalendar::GregorianCalendar(const TimeZone& zone, const Locale& aLocale, |
| UErrorCode& status) |
| : Calendar(zone, aLocale, status), |
| fGregorianCutover(kPapalCutover), |
| fNormalizedGregorianCutover(fGregorianCutover), |
| fGregorianCutoverYear(1582) |
| { |
| setTimeInMillis(getNow(), status); |
| } |
| |
| // ------------------------------------- |
| |
| GregorianCalendar::GregorianCalendar(int32_t year, int32_t month, int32_t date, |
| UErrorCode& status) |
| : Calendar(TimeZone::createDefault(), Locale::getDefault(), status), |
| fGregorianCutover(kPapalCutover), |
| fNormalizedGregorianCutover(fGregorianCutover), |
| fGregorianCutoverYear(1582) |
| { |
| set(Calendar::ERA, AD); |
| set(Calendar::YEAR, year); |
| set(Calendar::MONTH, month); |
| set(Calendar::DATE, date); |
| } |
| |
| // ------------------------------------- |
| |
| GregorianCalendar::GregorianCalendar(int32_t year, int32_t month, int32_t date, |
| int32_t hour, int32_t minute, UErrorCode& status) |
| : Calendar(TimeZone::createDefault(), Locale::getDefault(), status), |
| fGregorianCutover(kPapalCutover), |
| fNormalizedGregorianCutover(fGregorianCutover), |
| fGregorianCutoverYear(1582) |
| { |
| set(Calendar::ERA, AD); |
| set(Calendar::YEAR, year); |
| set(Calendar::MONTH, month); |
| set(Calendar::DATE, date); |
| set(Calendar::HOUR_OF_DAY, hour); |
| set(Calendar::MINUTE, minute); |
| } |
| |
| // ------------------------------------- |
| |
| GregorianCalendar::GregorianCalendar(int32_t year, int32_t month, int32_t date, |
| int32_t hour, int32_t minute, int32_t second, |
| UErrorCode& status) |
| : Calendar(TimeZone::createDefault(), Locale::getDefault(), status), |
| fGregorianCutover(kPapalCutover), |
| fNormalizedGregorianCutover(fGregorianCutover), |
| fGregorianCutoverYear(1582) |
| { |
| set(Calendar::ERA, AD); |
| set(Calendar::YEAR, year); |
| set(Calendar::MONTH, month); |
| set(Calendar::DATE, date); |
| set(Calendar::HOUR_OF_DAY, hour); |
| set(Calendar::MINUTE, minute); |
| set(Calendar::SECOND, second); |
| } |
| |
| // ------------------------------------- |
| |
| GregorianCalendar::~GregorianCalendar() |
| { |
| } |
| |
| // ------------------------------------- |
| |
| GregorianCalendar::GregorianCalendar(const GregorianCalendar &source) |
| : Calendar(source), |
| fGregorianCutover(source.fGregorianCutover), |
| fNormalizedGregorianCutover(source.fNormalizedGregorianCutover), |
| fGregorianCutoverYear(source.fGregorianCutoverYear) |
| { |
| } |
| |
| // ------------------------------------- |
| |
| Calendar* GregorianCalendar::clone() const |
| { |
| return new GregorianCalendar(*this); |
| } |
| |
| // ------------------------------------- |
| |
| GregorianCalendar & |
| GregorianCalendar::operator=(const GregorianCalendar &right) |
| { |
| if (this != &right) |
| { |
| Calendar::operator=(right); |
| fGregorianCutover = right.fGregorianCutover; |
| fNormalizedGregorianCutover = right.fNormalizedGregorianCutover; |
| fGregorianCutoverYear = right.fGregorianCutoverYear; |
| } |
| return *this; |
| } |
| |
| // ------------------------------------- |
| |
| UBool |
| GregorianCalendar::operator==(const Calendar& that) const |
| { |
| GregorianCalendar* other = (GregorianCalendar*)&that; |
| |
| return (this == &that) || |
| (Calendar::operator==(that) && |
| getDynamicClassID() == that.getDynamicClassID() && |
| fGregorianCutover == other->fGregorianCutover); |
| } |
| |
| // {sfb} API change? |
| UBool GregorianCalendar::equivalentTo(const Calendar& other) const |
| { |
| // Calendar override. |
| // Return true if another Calendar object is equivalent to this one. An equivalent |
| // Calendar will behave exactly as this one does, but may be set to a different time. |
| return Calendar::equivalentTo(other) && |
| fGregorianCutover == ((GregorianCalendar*)&other)->fGregorianCutover; |
| } |
| |
| // ------------------------------------- |
| |
| void |
| GregorianCalendar::setGregorianChange(UDate date, UErrorCode& status) |
| { |
| if (U_FAILURE(status)) |
| return; |
| |
| fGregorianCutover = date; |
| |
| // Precompute two internal variables which we use to do the actual |
| // cutover computations. These are the normalized cutover, which is the |
| // midnight at or before the cutover, and the cutover year. The |
| // normalized cutover is in pure date milliseconds; it contains no time |
| // of day or timezone component, and it used to compare against other |
| // pure date values. |
| UDate cutoverDay = floorDivide(fGregorianCutover, kOneDay); |
| fNormalizedGregorianCutover = cutoverDay * kOneDay; |
| |
| // Handle the rare case of numeric overflow. If the user specifies a |
| // change of UDate(Long.MIN_VALUE), in order to get a pure Gregorian |
| // calendar, then the epoch day is -106751991168, which when multiplied |
| // by ONE_DAY gives 9223372036794351616 -- the negative value is too |
| // large for 64 bits, and overflows into a positive value. We correct |
| // this by using the next day, which for all intents is semantically |
| // equivalent. |
| if (cutoverDay < 0 && fNormalizedGregorianCutover > 0) { |
| fNormalizedGregorianCutover = (cutoverDay + 1) * kOneDay; |
| } |
| |
| // Normalize the year so BC values are represented as 0 and negative |
| // values. |
| GregorianCalendar *cal = new GregorianCalendar(getTimeZone(), status); |
| if(U_FAILURE(status)) |
| return; |
| cal->setTime(date, status); |
| fGregorianCutoverYear = cal->get(YEAR, status); |
| if (cal->get(ERA, status) == BC) |
| fGregorianCutoverYear = 1 - fGregorianCutoverYear; |
| |
| delete cal; |
| } |
| |
| // ------------------------------------- |
| |
| UDate |
| GregorianCalendar::getGregorianChange() const |
| { |
| return fGregorianCutover; |
| } |
| |
| // ------------------------------------- |
| |
| UBool |
| GregorianCalendar::isLeapYear(int32_t year) const |
| { |
| return (year >= fGregorianCutoverYear ? |
| ((year%4 == 0) && ((year%100 != 0) || (year%400 == 0))) : // Gregorian |
| (year%4 == 0)); // Julian |
| } |
| |
| |
| // ------------------------------------- |
| |
| /** |
| * Compute the date-based fields given the milliseconds since the epoch start. |
| * Do not compute the time-based fields (HOUR, MINUTE, etc.). |
| * |
| * @param theTime the given time as LOCAL milliseconds, not UTC. |
| */ |
| void |
| GregorianCalendar::timeToFields(UDate theTime, UBool quick, UErrorCode& status) |
| { |
| if (U_FAILURE(status)) |
| return; |
| |
| int32_t rawYear; |
| int32_t year, yearOfWeekOfYear, month, date, dayOfWeek, locDayOfWeek, dayOfYear, era; |
| UBool isLeap; |
| |
| // Compute the year, month, and day of month from the given millis |
| if (theTime >= fNormalizedGregorianCutover) { |
| // The Gregorian epoch day is zero for Monday January 1, year 1. |
| double gregorianEpochDay = millisToJulianDay(theTime) - kJan1_1JulianDay; |
| // Here we convert from the day number to the multiple radix |
| // representation. We use 400-year, 100-year, and 4-year cycles. |
| // For example, the 4-year cycle has 4 years + 1 leap day; giving |
| // 1461 == 365*4 + 1 days. |
| int32_t rem[1]; |
| int32_t n400 = floorDivide(gregorianEpochDay, 146097, rem); // 400-year cycle length |
| int32_t n100 = floorDivide(rem[0], 36524, rem); // 100-year cycle length |
| int32_t n4 = floorDivide(rem[0], 1461, rem); // 4-year cycle length |
| int32_t n1 = floorDivide(rem[0], 365, rem); |
| rawYear = 400*n400 + 100*n100 + 4*n4 + n1; |
| dayOfYear = rem[0]; // zero-based day of year |
| if (n100 == 4 || n1 == 4) |
| dayOfYear = 365; // Dec 31 at end of 4- or 400-yr cycle |
| else |
| ++rawYear; |
| |
| isLeap = ((rawYear&0x3) == 0) && // equiv. to (rawYear%4 == 0) |
| (rawYear%100 != 0 || rawYear%400 == 0); |
| |
| // Gregorian day zero is a Monday |
| dayOfWeek = (int32_t)uprv_fmod(gregorianEpochDay + 1, 7); |
| } |
| else { |
| // The Julian epoch day (not the same as Julian Day) |
| // is zero on Saturday December 30, 0 (Gregorian). |
| double julianEpochDay = millisToJulianDay(theTime) - (kJan1_1JulianDay - 2); |
| rawYear = (int32_t) floorDivide(4*julianEpochDay + 1464, 1461.0); |
| |
| // Compute the Julian calendar day number for January 1, rawYear |
| double january1 = 365.0 * (rawYear - 1) + floorDivide((double)(rawYear - 1), 4.0); |
| dayOfYear = (int32_t)(julianEpochDay - january1); // 0-based |
| |
| // Julian leap years occurred historically every 4 years starting |
| // with 8 AD. Before 8 AD the spacing is irregular; every 3 years |
| // from 45 BC to 9 BC, and then none until 8 AD. However, we don't |
| // implement this historical detail; instead, we implement the |
| // computatinally cleaner proleptic calendar, which assumes |
| // consistent 4-year cycles throughout time. |
| isLeap = ((rawYear & 0x3) == 0); // equiv. to (rawYear%4 == 0) |
| |
| // Julian calendar day zero is a Saturday |
| dayOfWeek = (int32_t)uprv_fmod(julianEpochDay-1, 7); |
| } |
| |
| // Common Julian/Gregorian calculation |
| int32_t correction = 0; |
| int32_t march1 = isLeap ? 60 : 59; // zero-based DOY for March 1 |
| if (dayOfYear >= march1) |
| correction = isLeap ? 1 : 2; |
| month = (12 * (dayOfYear + correction) + 6) / 367; // zero-based month |
| date = dayOfYear - |
| (isLeap ? kLeapNumDays[month] : kNumDays[month]) + 1; // one-based DOM |
| |
| // Normalize day of week |
| dayOfWeek += (dayOfWeek < 0) ? (SUNDAY+7) : SUNDAY; |
| |
| |
| era = AD; |
| year = rawYear; |
| if (year < 1) { |
| era = BC; |
| year = 1 - year; |
| } |
| |
| // Adjust the doy for the cutover year. Do this AFTER the above |
| // computations using doy! [j81 - aliu] |
| if (rawYear == fGregorianCutoverYear && |
| theTime >= fNormalizedGregorianCutover) { |
| dayOfYear -= 10; |
| } |
| |
| // Calculate year of week of year |
| |
| |
| internalSet(ERA, era); |
| internalSet(YEAR, year); |
| internalSet(MONTH, month + JANUARY); // 0-based |
| internalSet(DATE, date); |
| internalSet(DAY_OF_WEEK, dayOfWeek); |
| internalSet(DAY_OF_YEAR, ++dayOfYear); // Convert from 0-based to 1-based |
| if (quick) |
| return; |
| |
| yearOfWeekOfYear = year; |
| |
| // Compute the week of the year. Valid week numbers run from 1 to 52 |
| // or 53, depending on the year, the first day of the week, and the |
| // minimal days in the first week. Days at the start of the year may |
| // fall into the last week of the previous year; days at the end of |
| // the year may fall into the first week of the next year. |
| int32_t relDow = (dayOfWeek + 7 - getFirstDayOfWeek()) % 7; // 0..6 |
| int32_t relDowJan1 = (dayOfWeek - dayOfYear + 701 - getFirstDayOfWeek()) % 7; // 0..6 |
| int32_t woy = (dayOfYear - 1 + relDowJan1) / 7; // 0..53 |
| if ((7 - relDowJan1) >= getMinimalDaysInFirstWeek()) { |
| ++woy; |
| // Check to see if we are in the last week; if so, we need |
| // to handle the case in which we are the first week of the |
| // next year. |
| int32_t lastDoy = yearLength(); |
| int32_t lastRelDow = (relDow + lastDoy - dayOfYear) % 7; |
| if (lastRelDow < 0) lastRelDow += 7; |
| if (dayOfYear > 359 && // Fast check which eliminates most cases |
| (6 - lastRelDow) >= getMinimalDaysInFirstWeek() && |
| (dayOfYear + 7 - relDow) > lastDoy) { |
| woy = 1; |
| yearOfWeekOfYear++; |
| } |
| } |
| else if (woy == 0) { |
| // We are the last week of the previous year. |
| int32_t prevDoy = dayOfYear + yearLength(rawYear - 1); |
| woy = weekNumber(prevDoy, dayOfWeek); |
| yearOfWeekOfYear--; |
| } |
| |
| |
| internalSet(WEEK_OF_YEAR, woy); |
| internalSet(YEAR_WOY, yearOfWeekOfYear); |
| |
| internalSet(WEEK_OF_MONTH, weekNumber(date, dayOfWeek)); |
| internalSet(DAY_OF_WEEK_IN_MONTH, (date-1) / 7 + 1); |
| |
| // Calculate localized day of week |
| locDayOfWeek = dayOfWeek-getFirstDayOfWeek()+1; |
| locDayOfWeek += (locDayOfWeek<1?7:0); |
| internalSet(DOW_LOCAL, locDayOfWeek); |
| } |
| |
| // ------------------------------------- |
| |
| /** |
| * Return the week number of a day, within a period. This may be the week number in |
| * a year, or the week number in a month. Usually this will be a value >= 1, but if |
| * some initial days of the period are excluded from week 1, because |
| * minimalDaysInFirstWeek is > 1, then the week number will be zero for those |
| * initial days. Requires the day of week for the given date in order to determine |
| * the day of week of the first day of the period. |
| * |
| * @param dayOfPeriod Day-of-year or day-of-month. Should be 1 for first day of period. |
| * @param day Day-of-week for given dayOfPeriod. 1-based with 1=Sunday. |
| * @return Week number, one-based, or zero if the day falls in part of the |
| * month before the first week, when there are days before the first |
| * week because the minimum days in the first week is more than one. |
| */ |
| int32_t |
| GregorianCalendar::weekNumber(int32_t dayOfPeriod, int32_t dayOfWeek) |
| { |
| // Determine the day of the week of the first day of the period |
| // in question (either a year or a month). Zero represents the |
| // first day of the week on this calendar. |
| int32_t periodStartDayOfWeek = (dayOfWeek - getFirstDayOfWeek() - dayOfPeriod + 1) % 7; |
| if (periodStartDayOfWeek < 0) |
| periodStartDayOfWeek += 7; |
| |
| // Compute the week number. Initially, ignore the first week, which |
| // may be fractional (or may not be). We add periodStartDayOfWeek in |
| // order to fill out the first week, if it is fractional. |
| int32_t weekNo = (dayOfPeriod + periodStartDayOfWeek - 1)/7; |
| |
| // If the first week is long enough, then count it. If |
| // the minimal days in the first week is one, or if the period start |
| // is zero, we always increment weekNo. |
| if ((7 - periodStartDayOfWeek) >= getMinimalDaysInFirstWeek()) |
| ++weekNo; |
| |
| return weekNo; |
| } |
| |
| // ------------------------------------- |
| |
| int32_t |
| GregorianCalendar::monthLength(int32_t month) const |
| { |
| int32_t year = internalGet(YEAR); |
| if(internalGetEra() == BC) { |
| year = 1 - year; |
| } |
| |
| return monthLength(month, year); |
| } |
| |
| // ------------------------------------- |
| |
| int32_t |
| GregorianCalendar::monthLength(int32_t month, int32_t year) const |
| { |
| return isLeapYear(year) ? kLeapMonthLength[month] : kMonthLength[month]; |
| } |
| |
| // ------------------------------------- |
| |
| int32_t |
| GregorianCalendar::yearLength(int32_t year) const |
| { |
| return isLeapYear(year) ? 366 : 365; |
| } |
| |
| // ------------------------------------- |
| |
| int32_t |
| GregorianCalendar::yearLength() const |
| { |
| return isLeapYear(internalGet(YEAR)) ? 366 : 365; |
| } |
| |
| // ------------------------------------- |
| |
| /** |
| * Overrides Calendar |
| * Converts UTC as milliseconds to time field values. |
| * The time is <em>not</em> |
| * recomputed first; to recompute the time, then the fields, call the |
| * <code>complete</code> method. |
| * @see Calendar#complete |
| */ |
| void |
| GregorianCalendar::computeFields(UErrorCode& status) |
| { |
| if (U_FAILURE(status)) |
| return; |
| |
| int32_t rawOffset = getTimeZone().getRawOffset(); |
| double localMillis = internalGetTime() + rawOffset; |
| |
| /* Check for very extreme values -- millis near Long.MIN_VALUE or |
| * Long.MAX_VALUE. For these values, adding the zone offset can push |
| * the millis past MAX_VALUE to MIN_VALUE, or vice versa. This produces |
| * the undesirable effect that the time can wrap around at the ends, |
| * yielding, for example, a UDate(Long.MAX_VALUE) with a big BC year |
| * (should be AD). Handle this by pinning such values to Long.MIN_VALUE |
| * or Long.MAX_VALUE. - liu 8/11/98 bug 4149677 */ |
| |
| /* {sfb} 9/04/98 |
| * Since in C++ we use doubles instead of longs for dates, there is |
| * an inherent loss of range in the calendar (because in Java you have all 64 |
| * bits to store data, while in C++ you have only 52 bits of mantissa. |
| * So, I will pin to these (2^52 - 1) values instead */ |
| |
| if(internalGetTime() > 0 && localMillis < 0 && rawOffset > 0) { |
| localMillis = LATEST_SUPPORTED_MILLIS; |
| } |
| else if(internalGetTime() < 0 && localMillis > 0 && rawOffset < 0) { |
| localMillis = EARLIEST_SUPPORTED_MILLIS; |
| } |
| |
| // Time to fields takes the wall millis (Standard or DST). |
| timeToFields(localMillis, FALSE, status); |
| |
| uint8_t era = (uint8_t) internalGetEra(); |
| int32_t year = internalGet(YEAR); |
| int32_t month = internalGet(MONTH); |
| int32_t date = internalGet(DATE); |
| uint8_t dayOfWeek = (uint8_t) internalGet(DAY_OF_WEEK); |
| |
| double days = uprv_floor(localMillis / kOneDay); |
| int32_t millisInDay = (int32_t) (localMillis - (days * kOneDay)); |
| if (millisInDay < 0) |
| millisInDay += U_MILLIS_PER_DAY; |
| |
| // Call getOffset() to get the TimeZone offset. The millisInDay value must |
| // be standard local millis. |
| int32_t dstOffset = getTimeZone().getOffset(era, year, month, date, dayOfWeek, millisInDay, |
| monthLength(month), status) - rawOffset; |
| if(U_FAILURE(status)) |
| return; |
| |
| // Adjust our millisInDay for DST, if necessary. |
| millisInDay += dstOffset; |
| |
| // If DST has pushed us into the next day, we must call timeToFields() again. |
| // This happens in DST between 12:00 am and 1:00 am every day. The call to |
| // timeToFields() will give the wrong day, since the Standard time is in the |
| // previous day. |
| if (millisInDay >= U_MILLIS_PER_DAY) { |
| UDate dstMillis = localMillis + dstOffset; |
| millisInDay -= U_MILLIS_PER_DAY; |
| // As above, check for and pin extreme values |
| if(localMillis > 0 && dstMillis < 0 && dstOffset > 0) { |
| dstMillis = LATEST_SUPPORTED_MILLIS; |
| } |
| else if(localMillis < 0 && dstMillis > 0 && dstOffset < 0) { |
| dstMillis = EARLIEST_SUPPORTED_MILLIS; |
| } |
| timeToFields(dstMillis, FALSE, status); |
| } |
| |
| // Fill in all time-related fields based on millisInDay. Call internalSet() |
| // so as not to perturb flags. |
| internalSet(MILLISECOND, millisInDay % 1000); |
| millisInDay /= 1000; |
| internalSet(SECOND, millisInDay % 60); |
| millisInDay /= 60; |
| internalSet(MINUTE, millisInDay % 60); |
| millisInDay /= 60; |
| internalSet(HOUR_OF_DAY, millisInDay); |
| internalSet(AM_PM, millisInDay / 12); // Assume AM == 0 |
| internalSet(HOUR, millisInDay % 12); |
| |
| internalSet(ZONE_OFFSET, rawOffset); |
| internalSet(DST_OFFSET, dstOffset); |
| |
| // Careful here: We are manually setting the time stamps[] flags to |
| // INTERNALLY_SET, so we must be sure that the above code actually does |
| // set all these fields. |
| for (int i=0; i<FIELD_COUNT; ++i) { |
| fStamp[i] = kInternallySet; |
| fIsSet[i] = TRUE; // Remove later |
| } |
| } |
| |
| // ------------------------------------- |
| |
| /** |
| * After adjustments such as add(MONTH), add(YEAR), we don't want the |
| * month to jump around. E.g., we don't want Jan 31 + 1 month to go to Mar |
| * 3, we want it to go to Feb 28. Adjustments which might run into this |
| * problem call this method to retain the proper month. |
| */ |
| void |
| GregorianCalendar::pinDayOfMonth() |
| { |
| int32_t monthLen = monthLength(internalGet(MONTH)); |
| int32_t dom = internalGet(DAY_OF_MONTH); |
| if(dom > monthLen) |
| set(DAY_OF_MONTH, monthLen); |
| } |
| |
| // ------------------------------------- |
| |
| UBool |
| GregorianCalendar::validateFields() const |
| { |
| for (int32_t field = 0; field < FIELD_COUNT; field++) { |
| // Ignore DATE and DAY_OF_YEAR which are handled below |
| if (field != DATE && |
| field != DAY_OF_YEAR && |
| isSet((EDateFields)field) && |
| ! boundsCheck(internalGet((EDateFields)field), (EDateFields)field)) |
| |
| return FALSE; |
| } |
| |
| // Values differ in Least-Maximum and Maximum should be handled |
| // specially. |
| if (isSet(DATE)) { |
| int32_t date = internalGet(DATE); |
| if (date < getMinimum(DATE) || |
| date > monthLength(internalGet(MONTH))) { |
| return FALSE; |
| } |
| } |
| |
| if (isSet(DAY_OF_YEAR)) { |
| int32_t days = internalGet(DAY_OF_YEAR); |
| if (days < 1 || days > yearLength()) |
| return FALSE; |
| } |
| |
| // Handle DAY_OF_WEEK_IN_MONTH, which must not have the value zero. |
| // We've checked against minimum and maximum above already. |
| if (isSet(DAY_OF_WEEK_IN_MONTH) && |
| 0 == internalGet(DAY_OF_WEEK_IN_MONTH)) |
| return FALSE; |
| |
| return TRUE; |
| } |
| |
| // ------------------------------------- |
| |
| UBool |
| GregorianCalendar::boundsCheck(int32_t value, EDateFields field) const |
| { |
| return value >= getMinimum(field) && value <= getMaximum(field); |
| } |
| |
| // ------------------------------------- |
| |
| UDate |
| GregorianCalendar::getEpochDay(UErrorCode& status) |
| { |
| complete(status); |
| // Divide by 1000 (convert to seconds) in order to prevent overflow when |
| // dealing with UDate(Long.MIN_VALUE) and UDate(Long.MAX_VALUE). |
| double wallSec = internalGetTime()/1000 + (internalGet(ZONE_OFFSET) + internalGet(DST_OFFSET))/1000; |
| |
| // {sfb} force conversion to double |
| return uprv_trunc(wallSec / (kOneDay/1000.0)); |
| //return floorDivide(wallSec, kOneDay/1000.0); |
| } |
| |
| // ------------------------------------- |
| |
| void |
| GregorianCalendar::computeTime(UErrorCode& status) |
| { |
| if (U_FAILURE(status)) |
| return; |
| |
| if (! isLenient() && ! validateFields()) { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| |
| // This function takes advantage of the fact that unset fields in |
| // the time field list have a value of zero. |
| |
| // The year is either the YEAR or the epoch year. YEAR_WOY is |
| // used only if WOY is the predominant field; see computeJulianDay. |
| int32_t year = (fStamp[YEAR] != kUnset) ? internalGet(YEAR) : kEpochYear; |
| int32_t era = AD; |
| if (fStamp[ERA] != kUnset) { |
| era = internalGet(ERA); |
| if (era == BC) |
| year = 1 - year; |
| // Even in lenient mode we disallow ERA values other than AD & BC |
| else if (era != AD) { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| } |
| |
| // First, use the year to determine whether to use the Gregorian or the |
| // Julian calendar. If the year is not the year of the cutover, this |
| // computation will be correct. But if the year is the cutover year, |
| // this may be incorrect. In that case, assume the Gregorian calendar, |
| // make the computation, and then recompute if the resultant millis |
| // indicate the wrong calendar has been assumed. |
| |
| // A date such as Oct. 10, 1582 does not exist in a Gregorian calendar |
| // with the default changeover of Oct. 15, 1582, since in such a |
| // calendar Oct. 4 (Julian) is followed by Oct. 15 (Gregorian). This |
| // algorithm will interpret such a date using the Julian calendar, |
| // yielding Oct. 20, 1582 (Gregorian). |
| UBool isGregorian = year >= fGregorianCutoverYear; |
| double julianDay = computeJulianDay(isGregorian, year); |
| double millis = julianDayToMillis(julianDay); |
| |
| // The following check handles portions of the cutover year BEFORE the |
| // cutover itself happens. The check for the julianDate number is for a |
| // rare case; it's a hardcoded number, but it's efficient. The given |
| // Julian day number corresponds to Dec 3, 292269055 BC, which |
| // corresponds to millis near Long.MIN_VALUE. The need for the check |
| // arises because for extremely negative Julian day numbers, the millis |
| // actually overflow to be positive values. Without the check, the |
| // initial date is interpreted with the Gregorian calendar, even when |
| // the cutover doesn't warrant it. |
| if (isGregorian != (millis >= fNormalizedGregorianCutover) && |
| julianDay != -106749550580.0) { // See above |
| julianDay = computeJulianDay(!isGregorian, year); |
| millis = julianDayToMillis(julianDay); |
| } |
| |
| // Do the time portion of the conversion. |
| |
| int32_t millisInDay = 0; |
| |
| // Find the best set of fields specifying the time of day. There |
| // are only two possibilities here; the HOUR_OF_DAY or the |
| // AM_PM and the HOUR. |
| int32_t hourOfDayStamp = fStamp[HOUR_OF_DAY]; |
| int32_t hourStamp = fStamp[HOUR]; |
| int32_t bestStamp = (hourStamp > hourOfDayStamp) ? hourStamp : hourOfDayStamp; |
| |
| // Hours |
| if (bestStamp != kUnset) { |
| if (bestStamp == hourOfDayStamp) |
| // Don't normalize here; let overflow bump into the next period. |
| // This is consistent with how we handle other fields. |
| millisInDay += internalGet(HOUR_OF_DAY); |
| |
| else { |
| // Don't normalize here; let overflow bump into the next period. |
| // This is consistent with how we handle other fields. |
| millisInDay += internalGet(HOUR); |
| |
| millisInDay += 12 * internalGet(AM_PM); // Default works for unset AM_PM |
| } |
| } |
| |
| // We use the fact that unset == 0; we start with millisInDay |
| // == HOUR_OF_DAY. |
| millisInDay *= 60; |
| millisInDay += internalGet(MINUTE); // now have minutes |
| millisInDay *= 60; |
| millisInDay += internalGet(SECOND); // now have seconds |
| millisInDay *= 1000; |
| millisInDay += internalGet(MILLISECOND); // now have millis |
| |
| // Compute the time zone offset and DST offset. There are two potential |
| // ambiguities here. We'll assume a 2:00 am (wall time) switchover time |
| // for discussion purposes here. |
| // 1. The transition into DST. Here, a designated time of 2:00 am - 2:59 am |
| // can be in standard or in DST depending. However, 2:00 am is an invalid |
| // representation (the representation jumps from 1:59:59 am Std to 3:00:00 am DST). |
| // We assume standard time. |
| // 2. The transition out of DST. Here, a designated time of 1:00 am - 1:59 am |
| // can be in standard or DST. Both are valid representations (the rep |
| // jumps from 1:59:59 DST to 1:00:00 Std). |
| // Again, we assume standard time. |
| // We use the TimeZone object, unless the user has explicitly set the ZONE_OFFSET |
| // or DST_OFFSET fields; then we use those fields. |
| const TimeZone& zone = getTimeZone(); |
| int32_t zoneOffset = (fStamp[ZONE_OFFSET] >= kMinimumUserStamp) |
| /*isSet(ZONE_OFFSET) && userSetZoneOffset*/ ? |
| internalGet(ZONE_OFFSET) : zone.getRawOffset(); |
| |
| // Now add date and millisInDay together, to make millis contain local wall |
| // millis, with no zone or DST adjustments |
| millis += millisInDay; |
| |
| int32_t dstOffset = 0; |
| if (fStamp[ZONE_OFFSET] >= kMinimumUserStamp |
| /*isSet(DST_OFFSET) && userSetDSTOffset*/) |
| dstOffset = internalGet(DST_OFFSET); |
| else { |
| /* Normalize the millisInDay to 0..ONE_DAY-1. If the millis is out |
| * of range, then we must call timeToFields() to recompute our |
| * fields. */ |
| int32_t normalizedMillisInDay [1]; |
| floorDivide(millis, (int32_t)kOneDay, normalizedMillisInDay); |
| |
| // We need to have the month, the day, and the day of the week. |
| // Calling timeToFields will compute the MONTH and DATE fields. |
| // If we're lenient then we need to call timeToFields() to |
| // normalize the year, month, and date numbers. |
| uint8_t dow; |
| if (isLenient() || fStamp[MONTH] == kUnset || fStamp[DATE] == kUnset |
| || millisInDay != normalizedMillisInDay[0]) { |
| timeToFields(millis, TRUE, status); // Use wall time; true == do quick computation |
| dow = (uint8_t) internalGet(DAY_OF_WEEK); // DOW is computed by timeToFields |
| } |
| else { |
| // It's tempting to try to use DAY_OF_WEEK here, if it |
| // is set, but we CAN'T. Even if it's set, it might have |
| // been set wrong by the user. We should rely only on |
| // the Julian day number, which has been computed correctly |
| // using the disambiguation algorithm above. [LIU] |
| dow = julianDayToDayOfWeek(julianDay); |
| } |
| |
| // It's tempting to try to use DAY_OF_WEEK here, if it |
| // is set, but we CAN'T. Even if it's set, it might have |
| // been set wrong by the user. We should rely only on |
| // the Julian day number, which has been computed correctly |
| // using the disambiguation algorithm above. [LIU] |
| dstOffset = zone.getOffset((uint8_t)era, |
| internalGet(YEAR), |
| internalGet(MONTH), |
| internalGet(DATE), |
| dow, |
| normalizedMillisInDay[0], |
| monthLength(internalGet(MONTH)), |
| status) - |
| zoneOffset; |
| // Note: Because we pass in wall millisInDay, rather than |
| // standard millisInDay, we interpret "1:00 am" on the day |
| // of cessation of DST as "1:00 am Std" (assuming the time |
| // of cessation is 2:00 am). |
| } |
| |
| // Store our final computed GMT time, with timezone adjustments. |
| internalSetTime(millis - zoneOffset - dstOffset); |
| } |
| |
| // ------------------------------------- |
| |
| /** |
| * Compute the julian day number of the day BEFORE the first day of |
| * January 1, year 1 of the given calendar. If julianDay == 0, it |
| * specifies (Jan. 1, 1) - 1, in whatever calendar we are using (Julian |
| * or Gregorian). |
| */ |
| double GregorianCalendar::computeJulianDayOfYear(UBool isGregorian, |
| int32_t year, UBool& isLeap) { |
| isLeap = year%4 == 0; |
| int32_t y = year - 1; |
| double julianDay = 365.0*y + floorDivide(y, 4) + (kJan1_1JulianDay - 3); |
| |
| if (isGregorian) { |
| isLeap = isLeap && ((year%100 != 0) || (year%400 == 0)); |
| // Add 2 because Gregorian calendar starts 2 days after Julian calendar |
| julianDay += floorDivide(y, 400) - floorDivide(y, 100) + 2; |
| } |
| |
| return julianDay; |
| } |
| |
| /** |
| * Compute the day of week, relative to the first day of week, from |
| * 0..6, of the current DOW_LOCAL or DAY_OF_WEEK fields. This is |
| * equivalent to get(DOW_LOCAL) - 1. |
| */ |
| int32_t GregorianCalendar::computeRelativeDOW() const { |
| int32_t relDow = 0; |
| if (fStamp[DOW_LOCAL] > fStamp[DAY_OF_WEEK]) { |
| relDow = internalGet(DOW_LOCAL) - 1; // 1-based |
| } else if (fStamp[DAY_OF_WEEK] != kUnset) { |
| relDow = internalGet(DAY_OF_WEEK) - getFirstDayOfWeek(); |
| if (relDow < 0) relDow += 7; |
| } |
| return relDow; |
| } |
| |
| /** |
| * Compute the day of week, relative to the first day of week, |
| * from 0..6 of the given julian day. |
| */ |
| int32_t GregorianCalendar::computeRelativeDOW(double julianDay) const { |
| int32_t relDow = julianDayToDayOfWeek(julianDay) - getFirstDayOfWeek(); |
| if (relDow < 0) { |
| relDow += 7; |
| } |
| return relDow; |
| } |
| |
| /** |
| * Compute the DOY using the WEEK_OF_YEAR field and the julian day |
| * of the day BEFORE January 1 of a year (a return value from |
| * computeJulianDayOfYear). |
| */ |
| int32_t GregorianCalendar::computeDOYfromWOY(double julianDayOfYear) const { |
| // Compute DOY from day of week plus week of year |
| |
| // Find the day of the week for the first of this year. This |
| // is zero-based, with 0 being the locale-specific first day of |
| // the week. Add 1 to get first day of year. |
| int32_t fdy = computeRelativeDOW(julianDayOfYear + 1); |
| |
| return |
| // Compute doy of first (relative) DOW of WOY 1 |
| (((7 - fdy) < getMinimalDaysInFirstWeek()) |
| ? (8 - fdy) : (1 - fdy)) |
| |
| // Adjust for the week number. |
| + (7 * (internalGet(WEEK_OF_YEAR) - 1)) |
| |
| // Adjust for the DOW |
| + computeRelativeDOW(); |
| } |
| |
| double |
| GregorianCalendar::computeJulianDay(UBool isGregorian, int32_t year) |
| { |
| // Find the most recent set of fields specifying the day within |
| // the year. These may be any of the following combinations: |
| // MONTH* + DAY_OF_MONTH* |
| // MONTH* + WEEK_OF_MONTH* + DAY_OF_WEEK |
| // MONTH* + DAY_OF_WEEK_IN_MONTH* + DAY_OF_WEEK |
| // DAY_OF_YEAR* |
| // WEEK_OF_YEAR* + DAY_OF_WEEK* |
| // WEEK_OF_YEAR* + DOW_LOCAL |
| // We look for the most recent of the fields marked thus*. If other |
| // fields are missing, we use their default values, which are those of |
| // the epoch start, or in the case of DAY_OF_WEEK, the first day in |
| // the week. |
| int32_t monthStamp = fStamp[MONTH]; |
| int32_t domStamp = fStamp[DAY_OF_MONTH]; |
| int32_t womStamp = fStamp[WEEK_OF_MONTH]; |
| int32_t dowimStamp = fStamp[DAY_OF_WEEK_IN_MONTH]; |
| int32_t doyStamp = fStamp[DAY_OF_YEAR]; |
| int32_t woyStamp = fStamp[WEEK_OF_YEAR]; |
| |
| UBool isLeap; |
| double julianDay; |
| |
| int32_t bestStamp = (monthStamp > domStamp) ? monthStamp : domStamp; |
| if (womStamp > bestStamp) bestStamp = womStamp; |
| if (dowimStamp > bestStamp) bestStamp = dowimStamp; |
| if (doyStamp > bestStamp) bestStamp = doyStamp; |
| if (woyStamp >= bestStamp) { |
| // Note use of >= here, rather than >. We will see woy == |
| // best if (a) all stamps are unset, in which case the |
| // specific handling of unset will be used below, or (b) all |
| // stamps are kInternallySet. In the latter case we want to |
| // use the YEAR_WOY if it is newer. |
| if (fStamp[YEAR_WOY] > fStamp[YEAR]) { |
| year = internalGet(YEAR_WOY); |
| if (fStamp[ERA] != kUnset && internalGet(ERA) == BC) { |
| year = 1 - year; |
| } |
| // Only the WOY algorithm correctly handles YEAR_WOY, so |
| // force its use by making its stamp the most recent. |
| // This only affects the situation in which all stamps are |
| // equal (see above). |
| bestStamp = ++woyStamp; |
| } else if (woyStamp > bestStamp) { |
| // The WOY stamp is not only equal to, but newer than any |
| // other stamp. This means the WOY has been explicitly |
| // set, and will be used for computation. |
| bestStamp = woyStamp; |
| if (fStamp[YEAR_WOY] != kUnset && fStamp[YEAR_WOY] >= fStamp[YEAR]) { |
| |
| // The YEAR_WOY is set, and is not superceded by the |
| // YEAR; use it. |
| year = internalGet(YEAR_WOY); |
| } |
| |
| /* At this point we cannot avoid using the WEEK_OF_YEAR together |
| * with the YEAR field, since the YEAR_WOY is unavailable. Our goal |
| * is round-trip field integrity. We cannot guarantee round-trip |
| * time integrity because the YEAR + WOY combination may be |
| * ambiguous; consider a calendar with MDFW 3 and FDW Sunday. YEAR |
| * 1997 + WOY 1 + DOW Wednesday specifies two days: Jan 1 1997, and |
| * Dec 31 1997. However, we can guarantee that the YEAR fields, as |
| * set, will remain unchanged. |
| * |
| * In general, YEAR and YEAR_WOY are equal, but at the ends of the |
| * years, the YEAR and YEAR_WOY can differ by one. To detect this |
| * in WOY 1, we look at the position of WOY 1. If it extends into |
| * the previous year, then we check the DOW and see if it falls in |
| * the previous year. If so, we increment the year. This allows us |
| * to have round-trip integrity on the YEAR field. |
| * |
| * If the WOY is >= 52, then we do an intial computation of the DOY |
| * for the current year. If this exceeds the length of this year, |
| * we decrement the year. Again, this provides round-trip integrity |
| * on the YEAR field. - aliu |
| */ |
| |
| else if (internalGet(WEEK_OF_YEAR) == 1) { |
| // YEAR_WOY has not been set, so we must use the YEAR. |
| // Since WOY computations rely on the YEAR_WOY, not the |
| // YEAR, we must guess at its value. It is usually equal |
| // to the YEAR, but may be one greater in WOY 1, and may |
| // be one less in WOY >= 52. Note that YEAR + WOY is |
| // ambiguous (YEAR_WOY + WOY is not). |
| |
| // FDW = Mon, MDFW = 2, Mon Dec 27 1999, WOY 1, YEAR_WOY 2000 |
| |
| // Find out where WOY 1 falls; some of it may extend |
| // into the previous year. If so, and if the DOW is |
| // one of those days, then increment the YEAR_WOY. |
| julianDay = computeJulianDayOfYear(isGregorian, year, isLeap); |
| int32_t fdy = computeRelativeDOW(1 + julianDay); |
| |
| int32_t doy = |
| (((7 - fdy) < getMinimalDaysInFirstWeek()) |
| ? (8 - fdy) : (1 - fdy)); |
| |
| if (doy < 1) { |
| // Some of WOY 1 for YEAR year extends into YEAR |
| // year-1 if doy < 1. doy == 0 -- 1 day of WOY 1 |
| // in previous year; doy == -1 -- 2 days, etc. |
| |
| // Compute the day of week, relative to the first day of week, |
| // from 0..6. |
| int32_t relDow = computeRelativeDOW(); |
| |
| // Range of days that are in YEAR year (as opposed |
| // to YEAR year-1) are DOY == 1..6+doy. Range of |
| // days of the week in YEAR year are fdy..fdy + 5 |
| // + doy. These are relative DOWs. |
| if ((relDow < fdy) || (relDow > (fdy + 5 + doy))) { |
| ++year; |
| } |
| } |
| |
| } else if (internalGet(WEEK_OF_YEAR) >= 52) { |
| // FDW = Mon, MDFW = 4, Sat Jan 01 2000, WOY 52, YEAR_WOY 1999 |
| julianDay = computeJulianDayOfYear(isGregorian, year, isLeap); |
| if (computeDOYfromWOY(julianDay) > yearLength(year)) { |
| --year; |
| } |
| // It's tempting to take our julianDay and DOY here, in an else |
| // clause, and return them, since they are correct. However, |
| // this neglects the cutover adjustment, and it's easier to |
| // maintain the code if everything goes through the same control |
| // path below. - aliu |
| } |
| } |
| } |
| |
| // The following if() clause checks if the month field |
| // predominates. This set of computations must be done BEFORE |
| // using the year, since the year value may be adjusted here. |
| UBool useMonth = FALSE; |
| int32_t month = 0; |
| if (bestStamp != kUnset && |
| (bestStamp == monthStamp || |
| bestStamp == domStamp || |
| bestStamp == womStamp || |
| bestStamp == dowimStamp)) { |
| useMonth = TRUE; |
| |
| // We have the month specified. Make it 0-based for the algorithm. |
| month = (monthStamp != kUnset) ? internalGet(MONTH) - JANUARY : 0; |
| |
| // If the month is out of range, adjust it into range |
| if (month < 0 || month > 11) { |
| int32_t rem[1]; |
| year += floorDivide(month, 12, rem); |
| month = rem[0]; |
| } |
| } |
| |
| // Compute the julian day number of the day BEFORE the first day of |
| // January 1, year 1 of the given calendar. If julianDay == 0, it |
| // specifies (Jan. 1, 1) - 1, in whatever calendar we are using (Julian |
| // or Gregorian). |
| julianDay = computeJulianDayOfYear(isGregorian, year, isLeap); |
| |
| if (useMonth) { |
| |
| // Move julianDay to the day BEFORE the first of the month. |
| julianDay += isLeap ? kLeapNumDays[month] : kNumDays[month]; |
| int32_t date = 0; |
| |
| if (bestStamp == domStamp || |
| bestStamp == monthStamp) { |
| |
| date = (domStamp != kUnset) ? internalGet(DAY_OF_MONTH) : 1; |
| } |
| else { // assert(bestStamp == womStamp || bestStamp == dowimStamp) |
| // Compute from day of week plus week number or from the day of |
| // week plus the day of week in month. The computations are |
| // almost identical. |
| |
| // Find the day of the week for the first of this month. This |
| // is zero-based, with 0 being the locale-specific first day of |
| // the week. Add 1 to get first day of month. |
| int32_t fdm = computeRelativeDOW(julianDay + 1); |
| |
| // Find the start of the first week. This will be a date from |
| // 1..-6. It represents the locale-specific first day of the |
| // week of the first day of the month, ignoring minimal days in |
| // first week. |
| date = 1 - fdm + ((fStamp[DAY_OF_WEEK] != kUnset) ? |
| (internalGet(DAY_OF_WEEK) - getFirstDayOfWeek()) : 0); |
| |
| if (bestStamp == womStamp) { |
| // Adjust for minimal days in first week. |
| if ((7 - fdm) < getMinimalDaysInFirstWeek()) |
| date += 7; |
| |
| // Now adjust for the week number. |
| date += 7 * (internalGet(WEEK_OF_MONTH) - 1); |
| } |
| else { // assert(bestStamp == dowimStamp) |
| // Adjust into the month, if needed. |
| if (date < 1) date += 7; |
| |
| // We are basing this on the day-of-week-in-month. The only |
| // trickiness occurs if the day-of-week-in-month is |
| // negative. |
| int32_t dim = internalGet(DAY_OF_WEEK_IN_MONTH); |
| if (dim >= 0) { |
| date += 7*(dim - 1); |
| } else { |
| // Move date to the last of this day-of-week in this |
| // month, then back up as needed. If dim==-1, we don't |
| // back up at all. If dim==-2, we back up once, etc. |
| // Don't back up past the first of the given day-of-week |
| // in this month. Note that we handle -2, -3, |
| // etc. correctly, even though values < -1 are |
| // technically disallowed. |
| date += ((monthLength(internalGet(MONTH), year) - date) / 7 + dim + 1) * 7; |
| } |
| } |
| } |
| |
| julianDay += date; |
| } |
| else { |
| // assert(bestStamp == doyStamp || bestStamp == woyStamp || |
| // bestStamp == UNSET). In the last case we should use January 1. |
| |
| // No month, start with January 0 (day before Jan 1), then adjust. |
| |
| int32_t doy = 0; |
| UBool doCutoverAdjustment = TRUE; |
| |
| if (bestStamp == kUnset) { |
| doy = 1; // Advance to January 1 |
| doCutoverAdjustment = FALSE; |
| } |
| else if (bestStamp == doyStamp) { |
| doy = internalGet(DAY_OF_YEAR); |
| } |
| else if (bestStamp == woyStamp) { |
| doy = computeDOYfromWOY(julianDay); |
| } |
| |
| // Adjust for cutover year [j81 - aliu] |
| if (doCutoverAdjustment && year == fGregorianCutoverYear && isGregorian) { |
| doy -= 10; |
| } |
| |
| julianDay += doy; |
| } |
| return julianDay; |
| } |
| |
| // ------------------------------------- |
| |
| double |
| GregorianCalendar::millisToJulianDay(UDate millis) |
| { |
| return (double)kEpochStartAsJulianDay + floorDivide(millis, kOneDay); |
| //return kEpochStartAsJulianDay + uprv_trunc(millis / kOneDay); |
| } |
| |
| // ------------------------------------- |
| |
| UDate |
| GregorianCalendar::julianDayToMillis(double julian) |
| { |
| return (UDate) ((julian - kEpochStartAsJulianDay) * (double) kOneDay); |
| } |
| |
| // ------------------------------------- |
| |
| double |
| GregorianCalendar::floorDivide(double numerator, double denominator) |
| { |
| return uprv_floor(numerator / denominator); |
| } |
| |
| // ------------------------------------- |
| |
| int32_t |
| GregorianCalendar::floorDivide(int32_t numerator, int32_t denominator) |
| { |
| // We do this computation in order to handle |
| // a numerator of Long.MIN_VALUE correctly |
| return (numerator >= 0) ? |
| numerator / denominator : |
| ((numerator + 1) / denominator) - 1; |
| } |
| |
| // ------------------------------------- |
| |
| int32_t |
| GregorianCalendar::floorDivide(int32_t numerator, int32_t denominator, int32_t remainder[]) |
| { |
| if (numerator >= 0) { |
| remainder[0] = numerator % denominator; |
| return numerator / denominator; |
| } |
| int32_t quotient = ((numerator + 1) / denominator) - 1; |
| remainder[0] = numerator - (quotient * denominator); |
| return quotient; |
| } |
| |
| // ------------------------------------- |
| |
| int32_t |
| GregorianCalendar::floorDivide(double numerator, int32_t denominator, int32_t remainder[]) |
| { |
| if (numerator >= 0) { |
| remainder[0] = (int32_t)uprv_fmod(numerator, denominator); |
| return (int32_t)uprv_trunc(numerator / denominator); |
| } |
| int32_t quotient = (int32_t)(uprv_trunc((numerator + 1) / denominator) - 1); |
| remainder[0] = (int32_t)(numerator - ((double)quotient * denominator)); |
| return quotient; |
| } |
| |
| |
| // ------------------------------------- |
| |
| int32_t |
| GregorianCalendar::aggregateStamp(int32_t stamp_a, int32_t stamp_b) |
| { |
| return (((stamp_a != kUnset && stamp_b != kUnset) |
| ? uprv_max(stamp_a, stamp_b) |
| : kUnset)); |
| } |
| |
| // ------------------------------------- |
| |
| void |
| GregorianCalendar::add(EDateFields field, int32_t amount, UErrorCode& status) |
| { |
| if (U_FAILURE(status)) |
| return; |
| |
| if (amount == 0) |
| return; // Do nothing! |
| complete(status); |
| |
| if (field == YEAR || field == YEAR_WOY) { |
| int32_t year = internalGet(field); |
| int32_t era = internalGetEra(); |
| year += (era == AD) ? amount : -amount; |
| if (year > 0) |
| set(field, year); |
| else { // year <= 0 |
| set(field, 1 - year); |
| // if year == 0, you get 1 BC |
| set(ERA, (AD + BC) - era); |
| } |
| pinDayOfMonth(); |
| } |
| else if (field == MONTH) { |
| int32_t month = internalGet(MONTH) + amount; |
| if (month >= 0) { |
| add(YEAR, (int32_t) (month / 12), status); |
| set(MONTH, (int32_t) (month % 12)); |
| } |
| else { // month < 0 |
| |
| add(YEAR, (int32_t) ((month + 1) / 12) - 1, status); |
| month %= 12; |
| if (month < 0) |
| month += 12; |
| set(MONTH, JANUARY + month); |
| } |
| pinDayOfMonth(); |
| } |
| else if (field == ERA) { |
| int32_t era = internalGet(ERA) + amount; |
| if (era < 0) |
| era = 0; |
| if (era > 1) |
| era = 1; |
| set(ERA, era); |
| } |
| else { |
| // We handle most fields here. The algorithm is to add a computed amount |
| // of millis to the current millis. The only wrinkle is with DST -- if |
| // the result of the add operation is to move from DST to Standard, or vice |
| // versa, we need to adjust by an hour forward or back, respectively. |
| // Otherwise you get weird effects in which the hour seems to shift when |
| // you add to the DAY_OF_MONTH field, for instance. |
| |
| // We only adjust the DST for fields larger than an hour. For fields |
| // smaller than an hour, we cannot adjust for DST without causing problems. |
| // for instance, if you add one hour to April 5, 1998, 1:00 AM, in PST, |
| // the time becomes "2:00 AM PDT" (an illegal value), but then the adjustment |
| // sees the change and compensates by subtracting an hour. As a result the |
| // time doesn't advance at all. |
| |
| // {sfb} do we want to use a double here, or a int32_t? |
| // probably a double, since if we used a int32_t in the |
| // WEEK_OF_YEAR clause below, if delta was greater than approx. |
| // 7.1 we would reach the limit of a int32_t |
| double delta = amount; |
| UBool adjustDST = TRUE; |
| |
| switch (field) { |
| case WEEK_OF_YEAR: |
| case WEEK_OF_MONTH: |
| case DAY_OF_WEEK_IN_MONTH: |
| delta *= 7 * 24 * 60 * 60 * 1000; // 7 days |
| break; |
| |
| case AM_PM: |
| delta *= 12 * 60 * 60 * 1000; // 12 hrs |
| break; |
| |
| case DATE: // synonym of DAY_OF_MONTH |
| case DAY_OF_YEAR: |
| case DAY_OF_WEEK: |
| case DOW_LOCAL: |
| delta *= 24 * 60 * 60 * 1000; // 1 day |
| break; |
| |
| case HOUR_OF_DAY: |
| case HOUR: |
| delta *= 60 * 60 * 1000; // 1 hour |
| adjustDST = FALSE; |
| break; |
| |
| case MINUTE: |
| delta *= 60 * 1000; // 1 minute |
| adjustDST = FALSE; |
| break; |
| |
| case SECOND: |
| delta *= 1000; // 1 second |
| adjustDST = FALSE; |
| break; |
| |
| case MILLISECOND: |
| adjustDST = FALSE; |
| break; |
| |
| case ZONE_OFFSET: |
| case DST_OFFSET: |
| default: |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| |
| // Save the current DST state. |
| int32_t dst = 0; |
| if (adjustDST) |
| dst = internalGet(DST_OFFSET); |
| |
| setTimeInMillis(internalGetTime() + delta, status); // Automatically computes fields if necessary |
| |
| if (adjustDST) { |
| // Now do the DST adjustment alluded to above. |
| // Only call setTimeInMillis if necessary, because it's an expensive call. |
| dst -= internalGet(DST_OFFSET); |
| if(dst!= 0) |
| setTimeInMillis(internalGetTime() + dst, status); |
| } |
| } |
| } |
| |
| // ------------------------------------- |
| |
| /** |
| * Roll a field by a signed amount. |
| * Note: This will be made public later. [LIU] |
| */ |
| void |
| GregorianCalendar::roll(EDateFields field, int32_t amount, UErrorCode& status) |
| { |
| if(U_FAILURE(status)) |
| return; |
| |
| if (amount == 0) |
| return; // Nothing to do |
| |
| |
| int32_t min = 0, max = 0, gap; |
| if (field >= 0 && field < FIELD_COUNT) { |
| complete(status); |
| min = getMinimum(field); |
| max = getMaximum(field); |
| } |
| |
| /* Some of the fields require special handling to work in the month |
| * containing the Gregorian cutover point. Do shared computations |
| * for these fields here. [j81 - aliu] */ |
| UBool inCutoverMonth = FALSE; |
| int32_t cMonthLen=0; // 'c' for cutover; in days |
| int32_t cDayOfMonth=0; // no discontinuity: [0, cMonthLen) |
| double cMonthStart=0.0; // in ms |
| if (field == DAY_OF_MONTH || field == WEEK_OF_MONTH) { |
| max = monthLength(internalGet(MONTH)); |
| double t = internalGetTime(); |
| // We subtract 1 from the DAY_OF_MONTH to make it zero-based, and an |
| // additional 10 if we are after the cutover. Thus the monthStart |
| // value will be correct iff we actually are in the cutover month. |
| cDayOfMonth = internalGet(DAY_OF_MONTH) - ((t >= fGregorianCutover) ? 10 : 0); |
| cMonthStart = t - ((cDayOfMonth - 1) * kOneDay); |
| |
| // A month containing the cutover is 10 days shorter. |
| if ((cMonthStart < fGregorianCutover) && |
| (cMonthStart + (cMonthLen=(max-10))*kOneDay >= fGregorianCutover)) { |
| inCutoverMonth = TRUE; |
| } |
| } |
| |
| switch (field) { |
| case ERA: |
| case YEAR: |
| case YEAR_WOY: |
| case AM_PM: |
| case MINUTE: |
| case SECOND: |
| case MILLISECOND: |
| // These fields are handled simply, since they have fixed minima |
| // and maxima. The field DAY_OF_MONTH is almost as simple. Other |
| // fields are complicated, since the range within they must roll |
| // varies depending on the date. |
| break; |
| |
| case HOUR: |
| case HOUR_OF_DAY: |
| // Rolling the hour is difficult on the ONSET and CEASE days of |
| // daylight savings. For example, if the change occurs at |
| // 2 AM, we have the following progression: |
| // ONSET: 12 Std -> 1 Std -> 3 Dst -> 4 Dst |
| // CEASE: 12 Dst -> 1 Dst -> 1 Std -> 2 Std |
| // To get around this problem we don't use fields; we manipulate |
| // the time in millis directly. |
| { |
| // Assume min == 0 in calculations below |
| UDate start = getTime(status); |
| int32_t oldHour = internalGet(field); |
| int32_t newHour = (oldHour + amount) % (max + 1); |
| if(newHour < 0) |
| newHour += max + 1; |
| setTime(start + ((double)kOneHour * (newHour - oldHour)), status); |
| return; |
| } |
| case MONTH: |
| // Rolling the month involves both pinning the final value to [0, 11] |
| // and adjusting the DAY_OF_MONTH if necessary. We only adjust the |
| // DAY_OF_MONTH if, after updating the MONTH field, it is illegal. |
| // E.g., <jan31>.roll(MONTH, 1) -> <feb28> or <feb29>. |
| { |
| int32_t mon = (internalGet(MONTH) + amount) % 12; |
| if (mon < 0) |
| mon += 12; |
| set(MONTH, mon); |
| |
| // Keep the day of month in range. We don't want to spill over |
| // into the next month; e.g., we don't want jan31 + 1 mo -> feb31 -> |
| // mar3. |
| // NOTE: We could optimize this later by checking for dom <= 28 |
| // first. Do this if there appears to be a need. [LIU] |
| int32_t monthLen = monthLength(mon); |
| int32_t dom = internalGet(DAY_OF_MONTH); |
| if (dom > monthLen) |
| set(DAY_OF_MONTH, monthLen); |
| return; |
| } |
| |
| case WEEK_OF_YEAR: |
| { |
| // Unlike WEEK_OF_MONTH, WEEK_OF_YEAR never shifts the day of the |
| // week. However, rolling the week of the year can have seemingly |
| // strange effects simply because the year of the week of year |
| // may be different from the calendar year. For example, the |
| // date Dec 28, 1997 is the first day of week 1 of 1998 (if |
| // weeks start on Sunday and the minimal days in first week is |
| // <= 3). |
| int32_t woy = internalGet(WEEK_OF_YEAR); |
| // Get the ISO year, which matches the week of year. This |
| // may be one year before or after the calendar year. |
| int32_t isoYear = internalGet(YEAR_WOY); |
| int32_t isoDoy = internalGet(DAY_OF_YEAR); |
| if (internalGet(MONTH) == Calendar::JANUARY) { |
| if (woy >= 52) { |
| isoDoy += yearLength(isoYear); |
| } |
| } |
| else { |
| if (woy == 1) { |
| isoDoy -= yearLength(isoYear-1); |
| } |
| } |
| woy += amount; |
| // Do fast checks to avoid unnecessary computation: |
| if (woy < 1 || woy > 52) { |
| // Determine the last week of the ISO year. |
| // We do this using the standard formula we use |
| // everywhere in this file. If we can see that the |
| // days at the end of the year are going to fall into |
| // week 1 of the next year, we drop the last week by |
| // subtracting 7 from the last day of the year. |
| int32_t lastDoy = yearLength(isoYear); |
| int32_t lastRelDow = (lastDoy - isoDoy + internalGet(DAY_OF_WEEK) - |
| getFirstDayOfWeek()) % 7; |
| if (lastRelDow < 0) |
| lastRelDow += 7; |
| if ((6 - lastRelDow) >= getMinimalDaysInFirstWeek()) |
| lastDoy -= 7; |
| int32_t lastWoy = weekNumber(lastDoy, lastRelDow + 1); |
| woy = ((woy + lastWoy - 1) % lastWoy) + 1; |
| } |
| set(WEEK_OF_YEAR, woy); |
| set(YEAR_WOY, isoYear); // make YEAR_WOY timestamp > YEAR timestamp |
| return; |
| } |
| case WEEK_OF_MONTH: |
| { |
| // This is tricky, because during the roll we may have to shift |
| // to a different day of the week. For example: |
| |
| // s m t w r f s |
| // 1 2 3 4 5 |
| // 6 7 8 9 10 11 12 |
| |
| // When rolling from the 6th or 7th back one week, we go to the |
| // 1st (assuming that the first partial week counts). The same |
| // thing happens at the end of the month. |
| |
| // The other tricky thing is that we have to figure out whether |
| // the first partial week actually counts or not, based on the |
| // minimal first days in the week. And we have to use the |
| // correct first day of the week to delineate the week |
| // boundaries. |
| |
| // Here's our algorithm. First, we find the real boundaries of |
| // the month. Then we discard the first partial week if it |
| // doesn't count in this locale. Then we fill in the ends with |
| // phantom days, so that the first partial week and the last |
| // partial week are full weeks. We then have a nice square |
| // block of weeks. We do the usual rolling within this block, |
| // as is done elsewhere in this method. If we wind up on one of |
| // the phantom days that we added, we recognize this and pin to |
| // the first or the last day of the month. Easy, eh? |
| |
| // Another wrinkle: To fix jitterbug 81, we have to make all this |
| // work in the oddball month containing the Gregorian cutover. |
| // This month is 10 days shorter than usual, and also contains |
| // a discontinuity in the days; e.g., the default cutover month |
| // is Oct 1582, and goes from day of month 4 to day of month 15. |
| |
| // Normalize the DAY_OF_WEEK so that 0 is the first day of the week |
| // in this locale. We have dow in 0..6. |
| int32_t dow = internalGet(DAY_OF_WEEK) - getFirstDayOfWeek(); |
| if (dow < 0) |
| dow += 7; |
| |
| // Find the day of month, compensating for cutover discontinuity. |
| int32_t dom = inCutoverMonth ? cDayOfMonth : internalGet(DAY_OF_MONTH); |
| |
| // Find the day of the week (normalized for locale) for the first |
| // of the month. |
| int32_t fdm = (dow - dom + 1) % 7; |
| if (fdm < 0) |
| fdm += 7; |
| |
| // Get the first day of the first full week of the month, |
| // including phantom days, if any. Figure out if the first week |
| // counts or not; if it counts, then fill in phantom days. If |
| // not, advance to the first real full week (skip the partial week). |
| int32_t start; |
| if ((7 - fdm) < getMinimalDaysInFirstWeek()) |
| start = 8 - fdm; // Skip the first partial week |
| else |
| start = 1 - fdm; // This may be zero or negative |
| |
| // Get the day of the week (normalized for locale) for the last |
| // day of the month. |
| int32_t monthLen = inCutoverMonth ? cMonthLen : monthLength(internalGet(MONTH)); |
| int32_t ldm = (monthLen - dom + dow) % 7; |
| // We know monthLen >= DAY_OF_MONTH so we skip the += 7 step here. |
| |
| // Get the limit day for the blocked-off rectangular month; that |
| // is, the day which is one past the last day of the month, |
| // after the month has already been filled in with phantom days |
| // to fill out the last week. This day has a normalized DOW of 0. |
| int32_t limit = monthLen + 7 - ldm; |
| |
| // Now roll between start and (limit - 1). |
| gap = limit - start; |
| int32_t newDom = (dom + amount*7 - start) % gap; |
| if (newDom < 0) |
| newDom += gap; |
| newDom += start; |
| |
| // Finally, pin to the real start and end of the month. |
| if (newDom < 1) |
| newDom = 1; |
| if (newDom > monthLen) |
| newDom = monthLen; |
| |
| // Set the DAY_OF_MONTH. We rely on the fact that this field |
| // takes precedence over everything else (since all other fields |
| // are also set at this point). If this fact changes (if the |
| // disambiguation algorithm changes) then we will have to unset |
| // the appropriate fields here so that DAY_OF_MONTH is attended |
| // to. |
| |
| // If we are in the cutover month, manipulate ms directly. Don't do |
| // this in general because it doesn't work across DST boundaries |
| // (details, details). This takes care of the discontinuity. |
| if (inCutoverMonth) { |
| setTimeInMillis(cMonthStart + (newDom-1)*kOneDay, status); |
| } else { |
| set(DAY_OF_MONTH, newDom); |
| } |
| return; |
| } |
| case DAY_OF_MONTH: |
| if (inCutoverMonth) { |
| // The default computation works except when the current month |
| // contains the Gregorian cutover. We handle this special case |
| // here. [j81 - aliu] |
| double monthLen = cMonthLen * kOneDay; |
| double msIntoMonth = uprv_fmod(internalGetTime() - cMonthStart + |
| amount * kOneDay, monthLen); |
| if (msIntoMonth < 0) { |
| msIntoMonth += monthLen; |
| } |
| setTimeInMillis(cMonthStart + msIntoMonth, status); |
| return; |
| } else { |
| max = monthLength(internalGet(MONTH)); |
| // ...else fall through to default computation |
| } |
| break; |
| case DAY_OF_YEAR: |
| { |
| // Roll the day of year using millis. Compute the millis for |
| // the start of the year, and get the length of the year. |
| double delta = amount * kOneDay; // Scale up from days to millis |
| double min2 = internalGetTime() - (internalGet(DAY_OF_YEAR) - 1) * kOneDay; |
| int32_t yearLen = yearLength(); |
| internalSetTime( uprv_fmod((internalGetTime() + delta - min2), (yearLen * kOneDay))); |
| if (internalGetTime() < 0) |
| internalSetTime( internalGetTime() + yearLen * kOneDay); |
| |
| setTimeInMillis(internalGetTime() + min2, status); |
| return; |
| } |
| |
| case DAY_OF_WEEK: |
| case DOW_LOCAL: |
| { |
| // Roll the day of week using millis. Compute the millis for |
| // the start of the week, using the first day of week setting. |
| // Restrict the millis to [start, start+7days). |
| double delta = amount * kOneDay; // Scale up from days to millis |
| // Compute the number of days before the current day in this |
| // week. This will be a value 0..6. |
| int32_t leadDays = internalGet(field) - |
| ((field == DAY_OF_WEEK) ? getFirstDayOfWeek() : 1); |
| if (leadDays < 0) |
| leadDays += 7; |
| double min2 = internalGetTime() - leadDays * kOneDay; |
| internalSetTime(uprv_fmod((internalGetTime() + delta - min2), kOneWeek)); |
| if (internalGetTime() < 0) |
| internalSetTime(internalGetTime() + kOneWeek); |
| setTimeInMillis(internalGetTime() + min2, status); |
| return; |
| } |
| case DAY_OF_WEEK_IN_MONTH: |
| { |
| // Roll the day of week in the month using millis. Determine |
| // the first day of the week in the month, and then the last, |
| // and then roll within that range. |
| double delta = amount * kOneWeek; // Scale up from weeks to millis |
| // Find the number of same days of the week before this one |
| // in this month. |
| int32_t preWeeks = (internalGet(DAY_OF_MONTH) - 1) / 7; |
| // Find the number of same days of the week after this one |
| // in this month. |
| int32_t postWeeks = (monthLength(internalGet(MONTH)) - internalGet(DAY_OF_MONTH)) / 7; |
| // From these compute the min and gap millis for rolling. |
| double min2 = internalGetTime() - preWeeks * kOneWeek; |
| double gap2 = kOneWeek * (preWeeks + postWeeks + 1); // Must add 1! |
| // Roll within this range |
| internalSetTime(uprv_fmod((internalGetTime() + delta - min2), gap2)); |
| if (internalGetTime() < 0) |
| internalSetTime(internalGetTime() + gap2); |
| setTimeInMillis(internalGetTime() + min2, status); |
| return; |
| } |
| case ZONE_OFFSET: |
| case DST_OFFSET: |
| default: |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| // These fields cannot be rolled |
| } |
| |
| // These are the standard roll instructions. These work for all |
| // simple cases, that is, cases in which the limits are fixed, such |
| // as the hour, the month, and the era. |
| gap = max - min + 1; |
| int32_t value = internalGet(field) + amount; |
| value = (value - min) % gap; |
| if (value < 0) |
| value += gap; |
| value += min; |
| |
| set(field, value); |
| |
| } |
| |
| // ------------------------------------- |
| |
| int32_t |
| GregorianCalendar::getMinimum(EDateFields field) const |
| { |
| return kMinValues[field]; |
| } |
| |
| // ------------------------------------- |
| |
| int32_t |
| GregorianCalendar::getMaximum(EDateFields field) const |
| { |
| return kMaxValues[field]; |
| } |
| |
| // ------------------------------------- |
| |
| int32_t |
| GregorianCalendar::getGreatestMinimum(EDateFields field) const |
| { |
| return kMinValues[field]; |
| } |
| |
| // ------------------------------------- |
| |
| int32_t |
| GregorianCalendar::getLeastMaximum(EDateFields field) const |
| { |
| return kLeastMaxValues[field]; |
| } |
| |
| // ------------------------------------- |
| |
| int32_t |
| GregorianCalendar::getActualMinimum(EDateFields field) const |
| { |
| return getMinimum(field); |
| } |
| |
| // ------------------------------------- |
| |
| int32_t |
| GregorianCalendar::getActualMaximum(EDateFields field) const |
| { |
| /* It is a known limitation that the code here (and in getActualMinimum) |
| * won't behave properly at the extreme limits of GregorianCalendar's |
| * representable range (except for the code that handles the YEAR |
| * field). That's because the ends of the representable range are at |
| * odd spots in the year. For calendars with the default Gregorian |
| * cutover, these limits are Sun Dec 02 16:47:04 GMT 292269055 BC to Sun |
| * Aug 17 07:12:55 GMT 292278994 AD, somewhat different for non-GMT |
| * zones. As a result, if the calendar is set to Aug 1 292278994 AD, |
| * the actual maximum of DAY_OF_MONTH is 17, not 30. If the date is Mar |
| * 31 in that year, the actual maximum month might be Jul, whereas is |
| * the date is Mar 15, the actual maximum might be Aug -- depending on |
| * the precise semantics that are desired. Similar considerations |
| * affect all fields. Nonetheless, this effect is sufficiently arcane |
| * that we permit it, rather than complicating the code to handle such |
| * intricacies. - liu 8/20/98 */ |
| |
| UErrorCode status = U_ZERO_ERROR; |
| |
| switch (field) { |
| // we have functions that enable us to fast-path number of days in month |
| // of year |
| case DAY_OF_MONTH: |
| return monthLength(get(MONTH, status)); |
| |
| case DAY_OF_YEAR: |
| return yearLength(); |
| |
| // for week of year, week of month, or day of week in month, we |
| // just fall back on the default implementation in Calendar (I'm not sure |
| // we could do better by having special calculations here) |
| case WEEK_OF_YEAR: |
| case WEEK_OF_MONTH: |
| case DAY_OF_WEEK_IN_MONTH: |
| return Calendar::getActualMaximum(field, status); |
| |
| case YEAR: |
| case YEAR_WOY: |
| /* The year computation is no different, in principle, from the |
| * others, however, the range of possible maxima is large. In |
| * addition, the way we know we've exceeded the range is different. |
| * For these reasons, we use the special case code below to handle |
| * this field. |
| * |
| * The actual maxima for YEAR depend on the type of calendar: |
| * |
| * Gregorian = May 17, 292275056 BC - Aug 17, 292278994 AD |
| * Julian = Dec 2, 292269055 BC - Jan 3, 292272993 AD |
| * Hybrid = Dec 2, 292269055 BC - Aug 17, 292278994 AD |
| * |
| * We know we've exceeded the maximum when either the month, date, |
| * time, or era changes in response to setting the year. We don't |
| * check for month, date, and time here because the year and era are |
| * sufficient to detect an invalid year setting. NOTE: If code is |
| * added to check the month and date in the future for some reason, |
| * Feb 29 must be allowed to shift to Mar 1 when setting the year. |
| */ |
| { |
| Calendar *cal = (Calendar*)this->clone(); |
| cal->setLenient(TRUE); |
| |
| int32_t era = cal->get(ERA, status); |
| if(U_FAILURE(status)) |
| return 0; |
| |
| UDate d = cal->getTime(status); |
| if(U_FAILURE(status)) |
| return 0; |
| |
| /* Perform a binary search, with the invariant that lowGood is a |
| * valid year, and highBad is an out of range year. |
| */ |
| int32_t lowGood = kLeastMaxValues[field]; |
| int32_t highBad = kMaxValues[field] + 1; |
| while((lowGood + 1) < highBad) { |
| int32_t y = (lowGood + highBad) / 2; |
| cal->set(field, y); |
| if(cal->get(field, status) == y && cal->get(ERA, status) == era) { |
| lowGood = y; |
| } |
| else { |
| highBad = y; |
| cal->setTime(d, status); // Restore original fields |
| } |
| } |
| |
| delete cal; |
| return lowGood; |
| } |
| |
| // and we know none of the other fields have variable maxima in |
| // GregorianCalendar, so we can just return the fixed maximum |
| default: |
| return getMaximum(field); |
| } |
| } |
| |
| // ------------------------------------- |
| |
| UBool |
| GregorianCalendar::inDaylightTime(UErrorCode& status) const |
| { |
| if (U_FAILURE(status) || !getTimeZone().useDaylightTime()) |
| return FALSE; |
| |
| // Force an update of the state of the Calendar. |
| ((GregorianCalendar*)this)->complete(status); // cast away const |
| |
| return (UBool)(U_SUCCESS(status) ? (internalGet(DST_OFFSET) != 0) : FALSE); |
| } |
| |
| // ------------------------------------- |
| |
| /** |
| * Return the ERA. We need a special method for this because the |
| * default ERA is AD, but a zero (unset) ERA is BC. |
| */ |
| int32_t |
| GregorianCalendar::internalGetEra() const { |
| return isSet(ERA) ? internalGet(ERA) : AD; |
| } |
| |
| //eof |