ICU-23102 Refactor Chinese Calendar to avoid save/restore

Author: FrankYFTang

icu4j/main/core/src/main/java/com/ibm/icu/util/ChineseCalendar.java

@@ -128,7 +128,7 @@ public class ChineseCalendar extends Calendar {
      * 1813 and 2033, the leap month is after the Winter Solstice of that year. So
      * this value could be false for a date prior to the Winter Solstice of that
      * year but that year still has a leap month and therefor is a leap year.
-     * @see #computeChineseFields
+     * @see #computeMonthInfo
      */
     private transient boolean hasLeapMonthBetweenWinterSolstices;
 
@@ -823,31 +823,62 @@ private boolean isLeapMonthBetween(int newMoon1, int newMoon2) {
      * @stable ICU 2.8
      */
     protected void handleComputeFields(int julianDay) {
+        int days = julianDay - EPOCH_JULIAN_DAY; // local days
+        int gyear = getGregorianYear();
+        int gmonth = getGregorianMonth();
+        MonthInfo info = computeMonthInfo(days, gyear);
+
+        // Extended year and cycle year is based on the epoch year
+        int extended_year = gyear - epochYear;
+        int cycle_year = gyear - CHINESE_EPOCH_YEAR;
+        if (info.month < 10 ||
+            gmonth >= JULY) {
+            extended_year++;
+            cycle_year++;
+        }
+        int dayOfMonth = days - info.thisMoon + 1;
+
+        // 0->0,60  1->1,1  60->1,60  61->2,1  etc.
+        int[] yearOfCycle = new int[1];
+        int cycle = floorDivide(cycle_year-1, 60, yearOfCycle);
+
+        // 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.
+        int newYear = newYear(gyear);
+        if (days < newYear) {
+            newYear = newYear(gyear-1);
+        }
 
-        computeChineseFields(julianDay - EPOCH_JULIAN_DAY, // local days
-                             getGregorianYear(), getGregorianMonth(),
-                             true); // set all fields
+        hasLeapMonthBetweenWinterSolstices = info.hasLeapMonthBetweenWinterSolstices;
+        internalSet(EXTENDED_YEAR, extended_year);
+        internalSet(ERA, cycle+1);
+        internalSet(YEAR, yearOfCycle[0]+1);
+        internalSet(MONTH, info.month); // Convert from 1-based to 0-based
+        internalSet(ORDINAL_MONTH, info.ordinalMonth);
+        internalSet(DAY_OF_MONTH, dayOfMonth);
+        internalSet(IS_LEAP_MONTH, info.isLeapMonth?1:0);
+        internalSet(DAY_OF_YEAR, days - newYear + 1);
     }
 
-    /**
-     * Compute fields for the Chinese calendar system.  This method can
-     * either set all relevant fields, as required by
-     * <code>handleComputeFields()</code>, or it can just set the MONTH and
-     * IS_LEAP_MONTH fields, as required by
-     * <code>handleComputeMonthStart()</code>.
-     *
-     * <p>As a side effect, this method sets {@link #hasLeapMonthBetweenWinterSolstices}.
-     * @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.
-     */
-    private void computeChineseFields(int days, int gyear, int gmonth,
-                                      boolean setAllFields) {
+    class MonthInfo {
+        int month;
+        int ordinalMonth;
+        int thisMoon;
+        boolean isLeapMonth;
+        boolean hasLeapMonthBetweenWinterSolstices;
+        MonthInfo(int month, int ordinalMonth, int thisMoon, boolean isLeapMonth,
+                boolean hasLeapMonthBetweenWinterSolstices) {
+            this.month = month;
+            this.ordinalMonth = ordinalMonth;
+            this.thisMoon = thisMoon;
+            this.isLeapMonth = isLeapMonth;
+            this.hasLeapMonthBetweenWinterSolstices = hasLeapMonthBetweenWinterSolstices;
+        }
+    };
 
+    private MonthInfo computeMonthInfo(int days, int gyear) {
         // 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.
@@ -867,8 +898,8 @@ private void computeChineseFields(int days, int gyear, int gmonth,
         int firstMoon = newMoonNear(solsticeBefore + 1, true);
         int lastMoon = newMoonNear(solsticeAfter + 1, false);
         int thisMoon = newMoonNear(days + 1, false); // Start of this month
-        // Note: hasLeapMonthBetweenWinterSolstices is a member variable
-        hasLeapMonthBetweenWinterSolstices = synodicMonthsBetween(firstMoon, lastMoon) == 12;
+
+        boolean hasLeapMonthBetweenWinterSolstices = synodicMonthsBetween(firstMoon, lastMoon) == 12;
 
         int month = synodicMonthsBetween(firstMoon, thisMoon);
         int theNewYear = newYear(gyear);
@@ -890,42 +921,7 @@ private void computeChineseFields(int days, int gyear, int gmonth,
             hasNoMajorSolarTerm(thisMoon) &&
             !isLeapMonthBetween(firstMoon, newMoonNear(thisMoon - SYNODIC_GAP, false));
 
-        internalSet(MONTH, month-1); // Convert from 1-based to 0-based
-        internalSet(ORDINAL_MONTH, ordinalMonth);
-        internalSet(IS_LEAP_MONTH, isLeapMonth?1:0);
-
-        if (setAllFields) {
-
-            // Extended year and cycle year is based on the epoch year
-            int extended_year = gyear - epochYear;
-            int cycle_year = gyear - CHINESE_EPOCH_YEAR;
-            if (month < 11 ||
-                gmonth >= JULY) {
-                extended_year++;
-                cycle_year++;
-            }
-            int dayOfMonth = days - thisMoon + 1;
-
-            internalSet(EXTENDED_YEAR, extended_year);
-
-            // 0->0,60  1->1,1  60->1,60  61->2,1  etc.
-            int[] yearOfCycle = new int[1];
-            int cycle = floorDivide(cycle_year-1, 60, yearOfCycle);
-            internalSet(ERA, cycle+1);
-            internalSet(YEAR, yearOfCycle[0]+1);
-
-            internalSet(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.
-            int newYear = newYear(gyear);
-            if (days < newYear) {
-                newYear = newYear(gyear-1);
-            }
-            internalSet(DAY_OF_YEAR, days - newYear + 1);
-        }
+        return new MonthInfo(month-1, ordinalMonth, thisMoon, isLeapMonth, hasLeapMonthBetweenWinterSolstices);
     }
 
     //------------------------------------------------------------------
@@ -999,27 +995,17 @@ private int handleComputeMonthStartWithLeap(int eyear, int month, int isLeapMont
 
         int julianDay = newMoon + EPOCH_JULIAN_DAY;
 
-        // Save fields for later restoration
-        int saveMonth = internalGet(MONTH);
-        int saveOrdinalMonth = internalGet(ORDINAL_MONTH);
-        int saveIsLeapMonth = internalGet(IS_LEAP_MONTH);
-
         computeGregorianFields(julianDay);
 
         // This will modify the MONTH and IS_LEAP_MONTH fields (only)
-        computeChineseFields(newMoon, getGregorianYear(),
-                             getGregorianMonth(), false);        
+        MonthInfo info = computeMonthInfo(newMoon, getGregorianYear());
 
-        if (month != internalGet(MONTH) ||
-            isLeapMonth != internalGet(IS_LEAP_MONTH)) {
+        if (month != info.month ||
+            info.isLeapMonth != (isLeapMonth != 0) ) {
             newMoon = newMoonNear(newMoon + SYNODIC_GAP, true);
             julianDay = newMoon + EPOCH_JULIAN_DAY;
         }
 
-        internalSet(MONTH, saveMonth);
-        internalSet(ORDINAL_MONTH, saveOrdinalMonth);
-        internalSet(IS_LEAP_MONTH, saveIsLeapMonth);
-
         return julianDay - 1;
     }