// Copyright (C) 2016 and later: Unicode, Inc. and others. // License & terms of use: http://www.unicode.org/copyright.html /* ****************************************************************************** * Copyright (C) 2007-2014, International Business Machines Corporation * and others. All Rights Reserved. ****************************************************************************** * * File CHNSECAL.CPP * * Modification History: * * Date Name Description * 9/18/2007 ajmacher ported from java ChineseCalendar ***************************************************************************** */ #include "chnsecal.h" #if !UCONFIG_NO_FORMATTING #include "umutex.h" #include #include "gregoimp.h" // Math #include "astro.h" // CalendarAstronomer #include "unicode/simpletz.h" #include "uhash.h" #include "ucln_in.h" // Debugging #ifdef U_DEBUG_CHNSECAL # include # include static void debug_chnsecal_loc(const char *f, int32_t l) { fprintf(stderr, "%s:%d: ", f, l); } static void debug_chnsecal_msg(const char *pat, ...) { va_list ap; va_start(ap, pat); vfprintf(stderr, pat, ap); fflush(stderr); } // must use double parens, i.e.: U_DEBUG_CHNSECAL_MSG(("four is: %d",4)); #define U_DEBUG_CHNSECAL_MSG(x) {debug_chnsecal_loc(__FILE__,__LINE__);debug_chnsecal_msg x;} #else #define U_DEBUG_CHNSECAL_MSG(x) #endif // --- The cache -- static UMutex astroLock = U_MUTEX_INITIALIZER; // Protects access to gChineseCalendarAstro. static icu::CalendarAstronomer *gChineseCalendarAstro = NULL; // Lazy Creation & Access synchronized by class CalendarCache with a mutex. static icu::CalendarCache *gChineseCalendarWinterSolsticeCache = NULL; static icu::CalendarCache *gChineseCalendarNewYearCache = NULL; static icu::TimeZone *gChineseCalendarZoneAstroCalc = NULL; static icu::UInitOnce gChineseCalendarZoneAstroCalcInitOnce = U_INITONCE_INITIALIZER; /** * The start year of the Chinese calendar, the 61st year of the reign * of Huang Di. Some sources use the first year of his reign, * resulting in EXTENDED_YEAR values 60 years greater and ERA (cycle) * values one greater. */ static const int32_t CHINESE_EPOCH_YEAR = -2636; // Gregorian year /** * The offset from GMT in milliseconds at which we perform astronomical * computations. Some sources use a different historically accurate * offset of GMT+7:45:40 for years before 1929; we do not do this. */ static const int32_t CHINA_OFFSET = 8 * kOneHour; /** * Value to be added or subtracted from the local days of a new moon to * get close to the next or prior new moon, but not cross it. Must be * >= 1 and < CalendarAstronomer.SYNODIC_MONTH. */ static const int32_t SYNODIC_GAP = 25; U_CDECL_BEGIN static UBool calendar_chinese_cleanup(void) { if (gChineseCalendarAstro) { delete gChineseCalendarAstro; gChineseCalendarAstro = NULL; } if (gChineseCalendarWinterSolsticeCache) { delete gChineseCalendarWinterSolsticeCache; gChineseCalendarWinterSolsticeCache = NULL; } if (gChineseCalendarNewYearCache) { delete gChineseCalendarNewYearCache; gChineseCalendarNewYearCache = NULL; } if (gChineseCalendarZoneAstroCalc) { delete gChineseCalendarZoneAstroCalc; gChineseCalendarZoneAstroCalc = NULL; } gChineseCalendarZoneAstroCalcInitOnce.reset(); return TRUE; } U_CDECL_END U_NAMESPACE_BEGIN // Implementation of the ChineseCalendar class //------------------------------------------------------------------------- // Constructors... //------------------------------------------------------------------------- Calendar* ChineseCalendar::clone() const { return new ChineseCalendar(*this); } ChineseCalendar::ChineseCalendar(const Locale& aLocale, UErrorCode& success) : Calendar(TimeZone::createDefault(), aLocale, success), isLeapYear(FALSE), fEpochYear(CHINESE_EPOCH_YEAR), fZoneAstroCalc(getChineseCalZoneAstroCalc()) { setTimeInMillis(getNow(), success); // Call this again now that the vtable is set up properly. } ChineseCalendar::ChineseCalendar(const Locale& aLocale, int32_t epochYear, const TimeZone* zoneAstroCalc, UErrorCode &success) : Calendar(TimeZone::createDefault(), aLocale, success), isLeapYear(FALSE), fEpochYear(epochYear), fZoneAstroCalc(zoneAstroCalc) { setTimeInMillis(getNow(), success); // Call this again now that the vtable is set up properly. } ChineseCalendar::ChineseCalendar(const ChineseCalendar& other) : Calendar(other) { isLeapYear = other.isLeapYear; fEpochYear = other.fEpochYear; fZoneAstroCalc = other.fZoneAstroCalc; } ChineseCalendar::~ChineseCalendar() { } const char *ChineseCalendar::getType() const { return "chinese"; } static void U_CALLCONV initChineseCalZoneAstroCalc() { gChineseCalendarZoneAstroCalc = new SimpleTimeZone(CHINA_OFFSET, UNICODE_STRING_SIMPLE("CHINA_ZONE") ); ucln_i18n_registerCleanup(UCLN_I18N_CHINESE_CALENDAR, calendar_chinese_cleanup); } const TimeZone* ChineseCalendar::getChineseCalZoneAstroCalc(void) const { umtx_initOnce(gChineseCalendarZoneAstroCalcInitOnce, &initChineseCalZoneAstroCalc); return gChineseCalendarZoneAstroCalc; } //------------------------------------------------------------------------- // Minimum / Maximum access functions //------------------------------------------------------------------------- static const int32_t LIMITS[UCAL_FIELD_COUNT][4] = { // Minimum Greatest Least Maximum // Minimum Maximum { 1, 1, 83333, 83333}, // ERA { 1, 1, 60, 60}, // YEAR { 0, 0, 11, 11}, // MONTH { 1, 1, 50, 55}, // WEEK_OF_YEAR {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // WEEK_OF_MONTH { 1, 1, 29, 30}, // DAY_OF_MONTH { 1, 1, 353, 385}, // DAY_OF_YEAR {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // DAY_OF_WEEK { -1, -1, 5, 5}, // DAY_OF_WEEK_IN_MONTH {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // AM_PM {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // HOUR {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // HOUR_OF_DAY {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // MINUTE {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // SECOND {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // MILLISECOND {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // ZONE_OFFSET {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // DST_OFFSET { -5000000, -5000000, 5000000, 5000000}, // YEAR_WOY {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // DOW_LOCAL { -5000000, -5000000, 5000000, 5000000}, // EXTENDED_YEAR {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // JULIAN_DAY {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // MILLISECONDS_IN_DAY { 0, 0, 1, 1}, // IS_LEAP_MONTH }; /** * @draft ICU 2.4 */ int32_t ChineseCalendar::handleGetLimit(UCalendarDateFields field, ELimitType limitType) const { return LIMITS[field][limitType]; } //---------------------------------------------------------------------- // Calendar framework //---------------------------------------------------------------------- /** * Implement abstract Calendar method to return the extended year * defined by the current fields. This will use either the ERA and * YEAR field as the cycle and year-of-cycle, or the EXTENDED_YEAR * field as the continuous year count, depending on which is newer. * @stable ICU 2.8 */ int32_t ChineseCalendar::handleGetExtendedYear() { int32_t year; if (newestStamp(UCAL_ERA, UCAL_YEAR, kUnset) <= fStamp[UCAL_EXTENDED_YEAR]) { year = internalGet(UCAL_EXTENDED_YEAR, 1); // Default to year 1 } else { int32_t cycle = internalGet(UCAL_ERA, 1) - 1; // 0-based cycle // adjust to the instance specific epoch year = cycle * 60 + internalGet(UCAL_YEAR, 1) - (fEpochYear - CHINESE_EPOCH_YEAR); } return year; } /** * Override Calendar method to return the number of days in the given * extended year and month. * *

Note: This method also reads the IS_LEAP_MONTH field to determine * whether or not the given month is a leap month. * @stable ICU 2.8 */ int32_t ChineseCalendar::handleGetMonthLength(int32_t extendedYear, int32_t month) const { int32_t thisStart = handleComputeMonthStart(extendedYear, month, TRUE) - kEpochStartAsJulianDay + 1; // Julian day -> local days int32_t nextStart = newMoonNear(thisStart + SYNODIC_GAP, TRUE); return nextStart - thisStart; } /** * Override Calendar to compute several fields specific to the Chinese * calendar system. These are: * *

  • ERA *
  • YEAR *
  • MONTH *
  • DAY_OF_MONTH *
  • DAY_OF_YEAR *
  • EXTENDED_YEAR
* * The DAY_OF_WEEK and DOW_LOCAL fields are already set when this * method is called. The getGregorianXxx() methods return Gregorian * calendar equivalents for the given Julian day. * *

Compute the ChineseCalendar-specific field IS_LEAP_MONTH. * @stable ICU 2.8 */ void ChineseCalendar::handleComputeFields(int32_t julianDay, UErrorCode &/*status*/) { computeChineseFields(julianDay - kEpochStartAsJulianDay, // local days getGregorianYear(), getGregorianMonth(), TRUE); // set all fields } /** * Field resolution table that incorporates IS_LEAP_MONTH. */ const UFieldResolutionTable ChineseCalendar::CHINESE_DATE_PRECEDENCE[] = { { { UCAL_DAY_OF_MONTH, kResolveSTOP }, { UCAL_WEEK_OF_YEAR, UCAL_DAY_OF_WEEK, kResolveSTOP }, { UCAL_WEEK_OF_MONTH, UCAL_DAY_OF_WEEK, kResolveSTOP }, { UCAL_DAY_OF_WEEK_IN_MONTH, UCAL_DAY_OF_WEEK, kResolveSTOP }, { UCAL_WEEK_OF_YEAR, UCAL_DOW_LOCAL, kResolveSTOP }, { UCAL_WEEK_OF_MONTH, UCAL_DOW_LOCAL, kResolveSTOP }, { UCAL_DAY_OF_WEEK_IN_MONTH, UCAL_DOW_LOCAL, kResolveSTOP }, { UCAL_DAY_OF_YEAR, kResolveSTOP }, { kResolveRemap | UCAL_DAY_OF_MONTH, UCAL_IS_LEAP_MONTH, kResolveSTOP }, { kResolveSTOP } }, { { UCAL_WEEK_OF_YEAR, kResolveSTOP }, { UCAL_WEEK_OF_MONTH, kResolveSTOP }, { UCAL_DAY_OF_WEEK_IN_MONTH, kResolveSTOP }, { kResolveRemap | UCAL_DAY_OF_WEEK_IN_MONTH, UCAL_DAY_OF_WEEK, kResolveSTOP }, { kResolveRemap | UCAL_DAY_OF_WEEK_IN_MONTH, UCAL_DOW_LOCAL, kResolveSTOP }, { kResolveSTOP } }, {{kResolveSTOP}} }; /** * Override Calendar to add IS_LEAP_MONTH to the field resolution * table. * @stable ICU 2.8 */ const UFieldResolutionTable* ChineseCalendar::getFieldResolutionTable() const { return CHINESE_DATE_PRECEDENCE; } /** * Return the Julian day number of day before the first day of the * given month in the given extended year. * *

Note: This method reads the IS_LEAP_MONTH field to determine * whether the given month is a leap month. * @param eyear the extended year * @param month the zero-based month. The month is also determined * by reading the IS_LEAP_MONTH field. * @return the Julian day number of the day before the first * day of the given month and year * @stable ICU 2.8 */ int32_t ChineseCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const { ChineseCalendar *nonConstThis = (ChineseCalendar*)this; // cast away const // If the month is out of range, adjust it into range, and // modify the extended year value accordingly. if (month < 0 || month > 11) { double m = month; eyear += (int32_t)ClockMath::floorDivide(m, 12.0, m); month = (int32_t)m; } int32_t gyear = eyear + fEpochYear - 1; // Gregorian year int32_t theNewYear = newYear(gyear); int32_t newMoon = newMoonNear(theNewYear + month * 29, TRUE); int32_t julianDay = newMoon + kEpochStartAsJulianDay; // Save fields for later restoration int32_t saveMonth = internalGet(UCAL_MONTH); int32_t saveIsLeapMonth = internalGet(UCAL_IS_LEAP_MONTH); // Ignore IS_LEAP_MONTH field if useMonth is false int32_t isLeapMonth = useMonth ? saveIsLeapMonth : 0; UErrorCode status = U_ZERO_ERROR; nonConstThis->computeGregorianFields(julianDay, status); if (U_FAILURE(status)) return 0; // This will modify the MONTH and IS_LEAP_MONTH fields (only) nonConstThis->computeChineseFields(newMoon, getGregorianYear(), getGregorianMonth(), FALSE); if (month != internalGet(UCAL_MONTH) || isLeapMonth != internalGet(UCAL_IS_LEAP_MONTH)) { newMoon = newMoonNear(newMoon + SYNODIC_GAP, TRUE); julianDay = newMoon + kEpochStartAsJulianDay; } nonConstThis->internalSet(UCAL_MONTH, saveMonth); nonConstThis->internalSet(UCAL_IS_LEAP_MONTH, saveIsLeapMonth); return julianDay - 1; } /** * Override Calendar to handle leap months properly. * @stable ICU 2.8 */ void ChineseCalendar::add(UCalendarDateFields field, int32_t amount, UErrorCode& status) { switch (field) { case UCAL_MONTH: if (amount != 0) { int32_t dom = get(UCAL_DAY_OF_MONTH, status); if (U_FAILURE(status)) break; int32_t day = get(UCAL_JULIAN_DAY, status) - kEpochStartAsJulianDay; // Get local day if (U_FAILURE(status)) break; int32_t moon = day - dom + 1; // New moon offsetMonth(moon, dom, amount); } break; default: Calendar::add(field, amount, status); break; } } /** * Override Calendar to handle leap months properly. * @stable ICU 2.8 */ void ChineseCalendar::add(EDateFields field, int32_t amount, UErrorCode& status) { add((UCalendarDateFields)field, amount, status); } /** * Override Calendar to handle leap months properly. * @stable ICU 2.8 */ void ChineseCalendar::roll(UCalendarDateFields field, int32_t amount, UErrorCode& status) { switch (field) { case UCAL_MONTH: if (amount != 0) { int32_t dom = get(UCAL_DAY_OF_MONTH, status); if (U_FAILURE(status)) break; int32_t day = get(UCAL_JULIAN_DAY, status) - kEpochStartAsJulianDay; // Get local day if (U_FAILURE(status)) break; int32_t moon = day - dom + 1; // New moon (start of this month) // Note throughout the following: Months 12 and 1 are never // followed by a leap month (D&R p. 185). // Compute the adjusted month number m. This is zero-based // value from 0..11 in a non-leap year, and from 0..12 in a // leap year. int32_t m = get(UCAL_MONTH, status); // 0-based month if (U_FAILURE(status)) break; if (isLeapYear) { // (member variable) if (get(UCAL_IS_LEAP_MONTH, status) == 1) { ++m; } else { // Check for a prior leap month. (In the // following, month 0 is the first month of the // year.) Month 0 is never followed by a leap // month, and we know month m is not a leap month. // moon1 will be the start of month 0 if there is // no leap month between month 0 and month m; // otherwise it will be the start of month 1. int moon1 = moon - (int) (CalendarAstronomer::SYNODIC_MONTH * (m - 0.5)); moon1 = newMoonNear(moon1, TRUE); if (isLeapMonthBetween(moon1, moon)) { ++m; } } if (U_FAILURE(status)) break; } // Now do the standard roll computation on m, with the // allowed range of 0..n-1, where n is 12 or 13. int32_t n = isLeapYear ? 13 : 12; // Months in this year int32_t newM = (m + amount) % n; if (newM < 0) { newM += n; } if (newM != m) { offsetMonth(moon, dom, newM - m); } } break; default: Calendar::roll(field, amount, status); break; } } void ChineseCalendar::roll(EDateFields field, int32_t amount, UErrorCode& status) { roll((UCalendarDateFields)field, amount, status); } //------------------------------------------------------------------ // Support methods and constants //------------------------------------------------------------------ /** * Convert local days to UTC epoch milliseconds. * This is not an accurate conversion in that getTimezoneOffset * takes the milliseconds in GMT (not local time). In theory, more * accurate algorithm can be implemented but practically we do not need * to go through that complication as long as the historical timezone * changes did not happen around the 'tricky' new moon (new moon around * midnight). * * @param days days after January 1, 1970 0:00 in the astronomical base zone * @return milliseconds after January 1, 1970 0:00 GMT */ double ChineseCalendar::daysToMillis(double days) const { double millis = days * (double)kOneDay; if (fZoneAstroCalc != NULL) { int32_t rawOffset, dstOffset; UErrorCode status = U_ZERO_ERROR; fZoneAstroCalc->getOffset(millis, FALSE, rawOffset, dstOffset, status); if (U_SUCCESS(status)) { return millis - (double)(rawOffset + dstOffset); } } return millis - (double)CHINA_OFFSET; } /** * Convert UTC epoch milliseconds to local days. * @param millis milliseconds after January 1, 1970 0:00 GMT * @return days after January 1, 1970 0:00 in the astronomical base zone */ double ChineseCalendar::millisToDays(double millis) const { if (fZoneAstroCalc != NULL) { int32_t rawOffset, dstOffset; UErrorCode status = U_ZERO_ERROR; fZoneAstroCalc->getOffset(millis, FALSE, rawOffset, dstOffset, status); if (U_SUCCESS(status)) { return ClockMath::floorDivide(millis + (double)(rawOffset + dstOffset), kOneDay); } } return ClockMath::floorDivide(millis + (double)CHINA_OFFSET, kOneDay); } //------------------------------------------------------------------ // Astronomical computations //------------------------------------------------------------------ /** * Return the major solar term on or after December 15 of the given * Gregorian year, that is, the winter solstice of the given year. * Computations are relative to Asia/Shanghai time zone. * @param gyear a Gregorian year * @return days after January 1, 1970 0:00 Asia/Shanghai of the * winter solstice of the given year */ int32_t ChineseCalendar::winterSolstice(int32_t gyear) const { UErrorCode status = U_ZERO_ERROR; int32_t cacheValue = CalendarCache::get(&gChineseCalendarWinterSolsticeCache, gyear, status); if (cacheValue == 0) { // In books December 15 is used, but it fails for some years // using our algorithms, e.g.: 1298 1391 1492 1553 1560. That // is, winterSolstice(1298) starts search at Dec 14 08:00:00 // PST 1298 with a final result of Dec 14 10:31:59 PST 1299. double ms = daysToMillis(Grego::fieldsToDay(gyear, UCAL_DECEMBER, 1)); umtx_lock(&astroLock); if(gChineseCalendarAstro == NULL) { gChineseCalendarAstro = new CalendarAstronomer(); ucln_i18n_registerCleanup(UCLN_I18N_CHINESE_CALENDAR, calendar_chinese_cleanup); } gChineseCalendarAstro->setTime(ms); UDate solarLong = gChineseCalendarAstro->getSunTime(CalendarAstronomer::WINTER_SOLSTICE(), TRUE); umtx_unlock(&astroLock); // Winter solstice is 270 degrees solar longitude aka Dongzhi cacheValue = (int32_t)millisToDays(solarLong); CalendarCache::put(&gChineseCalendarWinterSolsticeCache, gyear, cacheValue, status); } if(U_FAILURE(status)) { cacheValue = 0; } return cacheValue; } /** * Return the closest new moon to the given date, searching either * forward or backward in time. * @param days days after January 1, 1970 0:00 Asia/Shanghai * @param after if true, search for a new moon on or after the given * date; otherwise, search for a new moon before it * @return days after January 1, 1970 0:00 Asia/Shanghai of the nearest * new moon after or before days */ int32_t ChineseCalendar::newMoonNear(double days, UBool after) const { umtx_lock(&astroLock); if(gChineseCalendarAstro == NULL) { gChineseCalendarAstro = new CalendarAstronomer(); ucln_i18n_registerCleanup(UCLN_I18N_CHINESE_CALENDAR, calendar_chinese_cleanup); } gChineseCalendarAstro->setTime(daysToMillis(days)); UDate newMoon = gChineseCalendarAstro->getMoonTime(CalendarAstronomer::NEW_MOON(), after); umtx_unlock(&astroLock); return (int32_t) millisToDays(newMoon); } /** * Return the nearest integer number of synodic months between * two dates. * @param day1 days after January 1, 1970 0:00 Asia/Shanghai * @param day2 days after January 1, 1970 0:00 Asia/Shanghai * @return the nearest integer number of months between day1 and day2 */ int32_t ChineseCalendar::synodicMonthsBetween(int32_t day1, int32_t day2) const { double roundme = ((day2 - day1) / CalendarAstronomer::SYNODIC_MONTH); return (int32_t) (roundme + (roundme >= 0 ? .5 : -.5)); } /** * Return the major solar term on or before a given date. This * will be an integer from 1..12, with 1 corresponding to 330 degrees, * 2 to 0 degrees, 3 to 30 degrees,..., and 12 to 300 degrees. * @param days days after January 1, 1970 0:00 Asia/Shanghai */ int32_t ChineseCalendar::majorSolarTerm(int32_t days) const { umtx_lock(&astroLock); if(gChineseCalendarAstro == NULL) { gChineseCalendarAstro = new CalendarAstronomer(); ucln_i18n_registerCleanup(UCLN_I18N_CHINESE_CALENDAR, calendar_chinese_cleanup); } gChineseCalendarAstro->setTime(daysToMillis(days)); UDate solarLongitude = gChineseCalendarAstro->getSunLongitude(); umtx_unlock(&astroLock); // Compute (floor(solarLongitude / (pi/6)) + 2) % 12 int32_t term = ( ((int32_t)(6 * solarLongitude / CalendarAstronomer::PI)) + 2 ) % 12; if (term < 1) { term += 12; } return term; } /** * Return true if the given month lacks a major solar term. * @param newMoon days after January 1, 1970 0:00 Asia/Shanghai of a new * moon */ UBool ChineseCalendar::hasNoMajorSolarTerm(int32_t newMoon) const { return majorSolarTerm(newMoon) == majorSolarTerm(newMoonNear(newMoon + SYNODIC_GAP, TRUE)); } //------------------------------------------------------------------ // Time to fields //------------------------------------------------------------------ /** * Return true if there is a leap month on or after month newMoon1 and * at or before month newMoon2. * @param newMoon1 days after January 1, 1970 0:00 astronomical base zone * of a new moon * @param newMoon2 days after January 1, 1970 0:00 astronomical base zone * of a new moon */ UBool ChineseCalendar::isLeapMonthBetween(int32_t newMoon1, int32_t newMoon2) const { #ifdef U_DEBUG_CHNSECAL // This is only needed to debug the timeOfAngle divergence bug. // Remove this later. Liu 11/9/00 if (synodicMonthsBetween(newMoon1, newMoon2) >= 50) { U_DEBUG_CHNSECAL_MSG(( "isLeapMonthBetween(%d, %d): Invalid parameters", newMoon1, newMoon2 )); } #endif return (newMoon2 >= newMoon1) && (isLeapMonthBetween(newMoon1, newMoonNear(newMoon2 - SYNODIC_GAP, FALSE)) || hasNoMajorSolarTerm(newMoon2)); } /** * Compute fields for the Chinese calendar system. This method can * either set all relevant fields, as required by * handleComputeFields(), or it can just set the MONTH and * IS_LEAP_MONTH fields, as required by * handleComputeMonthStart(). * *

As a side effect, this method sets {@link #isLeapYear}. * @param days days after January 1, 1970 0:00 astronomical base zone * of the date to compute fields for * @param gyear the Gregorian year of the given date * @param gmonth the Gregorian month of the given date * @param setAllFields if true, set the EXTENDED_YEAR, ERA, YEAR, * DAY_OF_MONTH, and DAY_OF_YEAR fields. In either case set the MONTH * and IS_LEAP_MONTH fields. */ void ChineseCalendar::computeChineseFields(int32_t days, int32_t gyear, int32_t gmonth, UBool setAllFields) { // Find the winter solstices before and after the target date. // These define the boundaries of this Chinese year, specifically, // the position of month 11, which always contains the solstice. // We want solsticeBefore <= date < solsticeAfter. int32_t solsticeBefore; int32_t solsticeAfter = winterSolstice(gyear); if (days < solsticeAfter) { solsticeBefore = winterSolstice(gyear - 1); } else { solsticeBefore = solsticeAfter; solsticeAfter = winterSolstice(gyear + 1); } // Find the start of the month after month 11. This will be either // the prior month 12 or leap month 11 (very rare). Also find the // start of the following month 11. int32_t firstMoon = newMoonNear(solsticeBefore + 1, TRUE); int32_t lastMoon = newMoonNear(solsticeAfter + 1, FALSE); int32_t thisMoon = newMoonNear(days + 1, FALSE); // Start of this month // Note: isLeapYear is a member variable isLeapYear = synodicMonthsBetween(firstMoon, lastMoon) == 12; int32_t month = synodicMonthsBetween(firstMoon, thisMoon); if (isLeapYear && isLeapMonthBetween(firstMoon, thisMoon)) { month--; } if (month < 1) { month += 12; } UBool isLeapMonth = isLeapYear && hasNoMajorSolarTerm(thisMoon) && !isLeapMonthBetween(firstMoon, newMoonNear(thisMoon - SYNODIC_GAP, FALSE)); internalSet(UCAL_MONTH, month-1); // Convert from 1-based to 0-based internalSet(UCAL_IS_LEAP_MONTH, isLeapMonth?1:0); if (setAllFields) { // Extended year and cycle year is based on the epoch year int32_t extended_year = gyear - fEpochYear; int cycle_year = gyear - CHINESE_EPOCH_YEAR; if (month < 11 || gmonth >= UCAL_JULY) { extended_year++; cycle_year++; } int32_t dayOfMonth = days - thisMoon + 1; internalSet(UCAL_EXTENDED_YEAR, extended_year); // 0->0,60 1->1,1 60->1,60 61->2,1 etc. int32_t yearOfCycle; int32_t cycle = ClockMath::floorDivide(cycle_year - 1, 60, yearOfCycle); internalSet(UCAL_ERA, cycle + 1); internalSet(UCAL_YEAR, yearOfCycle + 1); internalSet(UCAL_DAY_OF_MONTH, dayOfMonth); // Days will be before the first new year we compute if this // date is in month 11, leap 11, 12. There is never a leap 12. // New year computations are cached so this should be cheap in // the long run. int32_t theNewYear = newYear(gyear); if (days < theNewYear) { theNewYear = newYear(gyear-1); } internalSet(UCAL_DAY_OF_YEAR, days - theNewYear + 1); } } //------------------------------------------------------------------ // Fields to time //------------------------------------------------------------------ /** * Return the Chinese new year of the given Gregorian year. * @param gyear a Gregorian year * @return days after January 1, 1970 0:00 astronomical base zone of the * Chinese new year of the given year (this will be a new moon) */ int32_t ChineseCalendar::newYear(int32_t gyear) const { UErrorCode status = U_ZERO_ERROR; int32_t cacheValue = CalendarCache::get(&gChineseCalendarNewYearCache, gyear, status); if (cacheValue == 0) { int32_t solsticeBefore= winterSolstice(gyear - 1); int32_t solsticeAfter = winterSolstice(gyear); int32_t newMoon1 = newMoonNear(solsticeBefore + 1, TRUE); int32_t newMoon2 = newMoonNear(newMoon1 + SYNODIC_GAP, TRUE); int32_t newMoon11 = newMoonNear(solsticeAfter + 1, FALSE); if (synodicMonthsBetween(newMoon1, newMoon11) == 12 && (hasNoMajorSolarTerm(newMoon1) || hasNoMajorSolarTerm(newMoon2))) { cacheValue = newMoonNear(newMoon2 + SYNODIC_GAP, TRUE); } else { cacheValue = newMoon2; } CalendarCache::put(&gChineseCalendarNewYearCache, gyear, cacheValue, status); } if(U_FAILURE(status)) { cacheValue = 0; } return cacheValue; } /** * Adjust this calendar to be delta months before or after a given * start position, pinning the day of month if necessary. The start * position is given as a local days number for the start of the month * and a day-of-month. Used by add() and roll(). * @param newMoon the local days of the first day of the month of the * start position (days after January 1, 1970 0:00 Asia/Shanghai) * @param dom the 1-based day-of-month of the start position * @param delta the number of months to move forward or backward from * the start position */ void ChineseCalendar::offsetMonth(int32_t newMoon, int32_t dom, int32_t delta) { UErrorCode status = U_ZERO_ERROR; // Move to the middle of the month before our target month. newMoon += (int32_t) (CalendarAstronomer::SYNODIC_MONTH * (delta - 0.5)); // Search forward to the target month's new moon newMoon = newMoonNear(newMoon, TRUE); // Find the target dom int32_t jd = newMoon + kEpochStartAsJulianDay - 1 + dom; // Pin the dom. In this calendar all months are 29 or 30 days // so pinning just means handling dom 30. if (dom > 29) { set(UCAL_JULIAN_DAY, jd-1); // TODO Fix this. We really shouldn't ever have to // explicitly call complete(). This is either a bug in // this method, in ChineseCalendar, or in // Calendar.getActualMaximum(). I suspect the last. complete(status); if (U_FAILURE(status)) return; if (getActualMaximum(UCAL_DAY_OF_MONTH, status) >= dom) { if (U_FAILURE(status)) return; set(UCAL_JULIAN_DAY, jd); } } else { set(UCAL_JULIAN_DAY, jd); } } UBool ChineseCalendar::inDaylightTime(UErrorCode& status) const { // copied from GregorianCalendar if (U_FAILURE(status) || !getTimeZone().useDaylightTime()) return FALSE; // Force an update of the state of the Calendar. ((ChineseCalendar*)this)->complete(status); // cast away const return (UBool)(U_SUCCESS(status) ? (internalGet(UCAL_DST_OFFSET) != 0) : FALSE); } // default century static UDate gSystemDefaultCenturyStart = DBL_MIN; static int32_t gSystemDefaultCenturyStartYear = -1; static icu::UInitOnce gSystemDefaultCenturyInitOnce = U_INITONCE_INITIALIZER; UBool ChineseCalendar::haveDefaultCentury() const { return TRUE; } UDate ChineseCalendar::defaultCenturyStart() const { return internalGetDefaultCenturyStart(); } int32_t ChineseCalendar::defaultCenturyStartYear() const { return internalGetDefaultCenturyStartYear(); } static void U_CALLCONV initializeSystemDefaultCentury() { // initialize systemDefaultCentury and systemDefaultCenturyYear based // on the current time. They'll be set to 80 years before // the current time. UErrorCode status = U_ZERO_ERROR; ChineseCalendar calendar(Locale("@calendar=chinese"),status); if (U_SUCCESS(status)) { calendar.setTime(Calendar::getNow(), status); calendar.add(UCAL_YEAR, -80, status); gSystemDefaultCenturyStart = calendar.getTime(status); gSystemDefaultCenturyStartYear = calendar.get(UCAL_YEAR, status); } // We have no recourse upon failure unless we want to propagate the failure // out. } UDate ChineseCalendar::internalGetDefaultCenturyStart() const { // lazy-evaluate systemDefaultCenturyStart umtx_initOnce(gSystemDefaultCenturyInitOnce, &initializeSystemDefaultCentury); return gSystemDefaultCenturyStart; } int32_t ChineseCalendar::internalGetDefaultCenturyStartYear() const { // lazy-evaluate systemDefaultCenturyStartYear umtx_initOnce(gSystemDefaultCenturyInitOnce, &initializeSystemDefaultCentury); return gSystemDefaultCenturyStartYear; } UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ChineseCalendar) U_NAMESPACE_END #endif