ICU-23102 Refactor and simplify Calendar code

See #3470

icu4c/source/i18n/calendar.cpp

@@ -1236,16 +1236,31 @@ Calendar::set(int32_t year, int32_t month, int32_t date, int32_t hour, int32_t m
 // -------------------------------------
 int32_t Calendar::getRelatedYear(UErrorCode &status) const
 {
-    return get(UCAL_EXTENDED_YEAR, status);
+    int32_t year = get(UCAL_EXTENDED_YEAR, status);
+    if (U_FAILURE(status)) {
+        return 0;
+    }
+    if (uprv_add32_overflow(year, getRelatedYearDifference(), &year)) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return 0;
+    }
+    return year;
 }
 
 // -------------------------------------
 void Calendar::setRelatedYear(int32_t year)
 {
     // set extended year
+    if (uprv_add32_overflow(year, -getRelatedYearDifference(), &year)) {
+        return;
+    }
     set(UCAL_EXTENDED_YEAR, year);
 }
 
+int32_t Calendar::getRelatedYearDifference() const {
+    return 0;
+}
+
 // -------------------------------------
 
 void

icu4c/source/i18n/chnsecal.cpp

@@ -1074,25 +1074,8 @@ void ChineseCalendar::offsetMonth(int32_t newMoon, int32_t dayOfMonth, int32_t d
     }
 }
 
-constexpr uint32_t kChineseRelatedYearDiff = -2637;
-
-int32_t ChineseCalendar::getRelatedYear(UErrorCode &status) const
-{
-    int32_t year = get(UCAL_EXTENDED_YEAR, status);
-    if (U_FAILURE(status)) {
-        return 0;
-    }
-    if (uprv_add32_overflow(year, kChineseRelatedYearDiff, &year)) {
-        status = U_ILLEGAL_ARGUMENT_ERROR;
-        return 0;
-    }
-    return year;
-}
-
-void ChineseCalendar::setRelatedYear(int32_t year)
-{
-    // set extended year
-    set(UCAL_EXTENDED_YEAR, year - kChineseRelatedYearDiff);
+int32_t ChineseCalendar::getRelatedYearDifference() const {
+    return CHINESE_EPOCH_YEAR - 1;
 }
 
 IMPL_SYSTEM_DEFAULT_CENTURY(ChineseCalendar, "@calendar=chinese")

icu4c/source/i18n/chnsecal.h

@@ -204,19 +204,11 @@ class U_I18N_API ChineseCalendar : public Calendar {
   virtual void roll(UCalendarDateFields field, int32_t amount, UErrorCode &status) override;
   virtual void roll(EDateFields field, int32_t amount, UErrorCode &status) override;
 
+ protected:
   /**
-   * @return      The related Gregorian year; will be obtained by modifying the value
-   *              obtained by get from UCAL_EXTENDED_YEAR field
    * @internal
    */
-  virtual int32_t getRelatedYear(UErrorCode &status) const override;
-
-  /**
-   * @param year  The related Gregorian year to set; will be modified as necessary then
-   *              set in UCAL_EXTENDED_YEAR field
-   * @internal
-   */
-  virtual void setRelatedYear(int32_t year) override;
+  int32_t getRelatedYearDifference() const override;
 
   //----------------------------------------------------------------------
   // Internal methods & astronomical calculations

icu4c/source/i18n/coptccal.cpp

@@ -102,23 +102,6 @@ CopticCalendar::handleComputeFields(int32_t julianDay, UErrorCode& status)
     internalSet(UCAL_DAY_OF_YEAR, (30 * month) + day);
 }
 
-constexpr uint32_t kCopticRelatedYearDiff = 284;
-
-int32_t CopticCalendar::getRelatedYear(UErrorCode &status) const
-{
-    int32_t year = get(UCAL_EXTENDED_YEAR, status);
-    if (U_FAILURE(status)) {
-        return 0;
-    }
-    return year + kCopticRelatedYearDiff;
-}
-
-void CopticCalendar::setRelatedYear(int32_t year)
-{
-    // set extended year
-    set(UCAL_EXTENDED_YEAR, year - kCopticRelatedYearDiff);
-}
-
 IMPL_SYSTEM_DEFAULT_CENTURY(CopticCalendar, "@calendar=coptic")
 
 int32_t
@@ -127,6 +110,12 @@ CopticCalendar::getJDEpochOffset() const
     return COPTIC_JD_EPOCH_OFFSET;
 }
 
+int32_t
+CopticCalendar::getRelatedYearDifference() const {
+    constexpr int32_t kCopticCalendarRelatedYearDifference = 284;
+    return kCopticCalendarRelatedYearDifference;
+}
+
 
 U_NAMESPACE_END
 

icu4c/source/i18n/coptccal.h

@@ -154,25 +154,16 @@ public:
      */
     const char * getType() const override;
 
-    /**
-     * @return      The related Gregorian year; will be obtained by modifying the value
-     *              obtained by get from UCAL_EXTENDED_YEAR field
-     * @internal
-     */
-    virtual int32_t getRelatedYear(UErrorCode &status) const override;
-
-    /**
-     * @param year  The related Gregorian year to set; will be modified as necessary then
-     *              set in UCAL_EXTENDED_YEAR field
-     * @internal
-     */
-    virtual void setRelatedYear(int32_t year) override;
-
 protected:
     //-------------------------------------------------------------------------
     // Calendar framework
     //-------------------------------------------------------------------------
 
+    /**
+     * @internal
+     */
+    int32_t getRelatedYearDifference() const override;
+
     /**
      * Return the extended year defined by the current fields.
      * @internal

icu4c/source/i18n/dangical.cpp

@@ -158,25 +158,8 @@ const TimeZone* getAstronomerTimeZone(UErrorCode &status) {
     return gAstronomerTimeZone;
 }
 
-constexpr uint32_t kDangiRelatedYearDiff = -2333;
-
-int32_t DangiCalendar::getRelatedYear(UErrorCode &status) const
-{
-    int32_t year = get(UCAL_EXTENDED_YEAR, status);
-    if (U_FAILURE(status)) {
-        return 0;
-    }
-    if (uprv_add32_overflow(year, kDangiRelatedYearDiff, &year)) {
-        status = U_ILLEGAL_ARGUMENT_ERROR;
-        return 0;
-    }
-    return year;
-}
-
-void DangiCalendar::setRelatedYear(int32_t year)
-{
-    // set extended year
-    set(UCAL_EXTENDED_YEAR, year - kDangiRelatedYearDiff);
+int32_t DangiCalendar::getRelatedYearDifference() const {
+    return DANGI_EPOCH_YEAR - 1;
 }
 
 ChineseCalendar::Setting DangiCalendar::getSetting(UErrorCode& status) const {

icu4c/source/i18n/dangical.h

@@ -68,24 +68,6 @@ class DangiCalendar : public ChineseCalendar {
    */
   virtual DangiCalendar* clone() const override;
 
-  //----------------------------------------------------------------------
-  // Internal methods & astronomical calculations
-  //----------------------------------------------------------------------
-
-  /**
-   * @return      The related Gregorian year; will be obtained by modifying the value
-   *              obtained by get from UCAL_EXTENDED_YEAR field
-   * @internal
-   */
-  virtual int32_t getRelatedYear(UErrorCode &status) const override;
-
-  /**
-   * @param year  The related Gregorian year to set; will be modified as necessary then
-   *              set in UCAL_EXTENDED_YEAR field
-   * @internal
-   */
-  virtual void setRelatedYear(int32_t year) override;
-
  private:
 
   // UObject stuff
@@ -121,6 +103,11 @@ class DangiCalendar : public ChineseCalendar {
  protected:
   virtual Setting getSetting(UErrorCode& status) const override;
 
+  /*
+   * @internal
+   */
+  int32_t getRelatedYearDifference() const override;
+
  private:
  
   DangiCalendar(); // default constructor not implemented

icu4c/source/i18n/ethpccal.cpp

@@ -95,23 +95,6 @@ EthiopicCalendar::handleComputeFields(int32_t julianDay, UErrorCode& status)
     internalSet(UCAL_DAY_OF_YEAR, (30 * month) + day);
 }
 
-constexpr uint32_t kEthiopicRelatedYearDiff = 8;
-
-int32_t EthiopicCalendar::getRelatedYear(UErrorCode &status) const
-{
-    int32_t year = get(UCAL_EXTENDED_YEAR, status);
-    if (U_FAILURE(status)) {
-        return 0;
-    }
-    return year + kEthiopicRelatedYearDiff;
-}
-
-void EthiopicCalendar::setRelatedYear(int32_t year)
-{
-    // set extended year
-    set(UCAL_EXTENDED_YEAR, year - kEthiopicRelatedYearDiff);
-}
-
 IMPL_SYSTEM_DEFAULT_CENTURY(EthiopicCalendar, "@calendar=ethiopic")
 
 int32_t
@@ -121,6 +104,11 @@ EthiopicCalendar::getJDEpochOffset() const
 }
 
 
+int32_t EthiopicCalendar::getRelatedYearDifference() const {
+    constexpr int32_t kEthiopicCalendarRelatedYearDifference = 8;
+    return kEthiopicCalendarRelatedYearDifference;
+}
+
 //-------------------------------------------------------------------------
 // Constructors...
 //-------------------------------------------------------------------------
@@ -188,29 +176,17 @@ EthiopicAmeteAlemCalendar::handleGetLimit(UCalendarDateFields field, ELimitType
     return EthiopicCalendar::handleGetLimit(field, limitType);
 }
 
-constexpr uint32_t kEthiopicAmeteAlemRelatedYearDiff = -5492;
-
-int32_t EthiopicAmeteAlemCalendar::getRelatedYear(UErrorCode &status) const
-{
-    int32_t year = get(UCAL_EXTENDED_YEAR, status);
-    if (U_FAILURE(status)) {
-        return 0;
-    }
-    return year + kEthiopicAmeteAlemRelatedYearDiff;
-}
-
-void EthiopicAmeteAlemCalendar::setRelatedYear(int32_t year)
-{
-    // set extended year
-    set(UCAL_EXTENDED_YEAR, year - kEthiopicAmeteAlemRelatedYearDiff);
-}
-
 int32_t
 EthiopicAmeteAlemCalendar::defaultCenturyStartYear() const
 {
     return EthiopicCalendar::defaultCenturyStartYear() + AMETE_MIHRET_DELTA;
 }
 
+
+int32_t EthiopicAmeteAlemCalendar::getRelatedYearDifference() const {
+    constexpr int32_t kEthiopicAmeteAlemCalendarRelatedYearDifference = -5492;
+    return kEthiopicAmeteAlemCalendarRelatedYearDifference;
+}
 U_NAMESPACE_END
 
 #endif

icu4c/source/i18n/ethpccal.h

@@ -141,25 +141,16 @@ public:
      */
     virtual const char * getType() const override;
 
-    /**
-     * @return      The related Gregorian year; will be obtained by modifying the value
-     *              obtained by get from UCAL_EXTENDED_YEAR field
-     * @internal
-     */
-    virtual int32_t getRelatedYear(UErrorCode &status) const override;
-
-    /**
-     * @param year  The related Gregorian year to set; will be modified as necessary then
-     *              set in UCAL_EXTENDED_YEAR field
-     * @internal
-     */
-    virtual void setRelatedYear(int32_t year) override;
-
 protected:
     //-------------------------------------------------------------------------
     // Calendar framework
     //-------------------------------------------------------------------------
 
+    /**
+     * @internal
+     */
+    int32_t getRelatedYearDifference() const override;
+
     /**
      * Return the extended year defined by the current fields.
      * This calendar uses both AMETE_ALEM and AMETE_MIHRET.
@@ -302,25 +293,16 @@ public:
      */
     U_I18N_API static UClassID U_EXPORT2 getStaticClassID(); 
 
-    /**
-     * @return      The related Gregorian year; will be obtained by modifying the value
-     *              obtained by get from UCAL_EXTENDED_YEAR field
-     * @internal
-     */
-    virtual int32_t getRelatedYear(UErrorCode &status) const override;
-
-    /**
-     * @param year  The related Gregorian year to set; will be modified as necessary then
-     *              set in UCAL_EXTENDED_YEAR field
-     * @internal
-     */
-    virtual void setRelatedYear(int32_t year) override;
-
 protected:
     //-------------------------------------------------------------------------
     // Calendar framework
     //-------------------------------------------------------------------------
 
+    /**
+     * @internal
+     */
+    int32_t getRelatedYearDifference() const override;
+
     /**
      * Return the extended year defined by the current fields.
      * This calendar use only AMETE_ALEM for the era.

icu4c/source/i18n/hebrwcal.cpp

@@ -790,23 +790,6 @@ int64_t HebrewCalendar::handleComputeMonthStart(
     return day + 347997LL;
 }
 
-constexpr uint32_t kHebrewRelatedYearDiff = -3760;
-
-int32_t HebrewCalendar::getRelatedYear(UErrorCode &status) const
-{
-    int32_t year = get(UCAL_EXTENDED_YEAR, status);
-    if (U_FAILURE(status)) {
-        return 0;
-    }
-    return year + kHebrewRelatedYearDiff;
-}
-
-void HebrewCalendar::setRelatedYear(int32_t year)
-{
-    // set extended year
-    set(UCAL_EXTENDED_YEAR, year - kHebrewRelatedYearDiff);
-}
-
 IMPL_SYSTEM_DEFAULT_CENTURY(HebrewCalendar, "@calendar=hebrew")
 
 bool HebrewCalendar::inTemporalLeapYear(UErrorCode& status) const {
@@ -872,6 +855,11 @@ int32_t HebrewCalendar::internalGetMonth(UErrorCode& status) const {
     return Calendar::internalGetMonth(status);
 }
 
+int32_t HebrewCalendar::getRelatedYearDifference() const {
+    constexpr int32_t kHebrewCalendarRelatedYearDifference = -3760;
+    return kHebrewCalendarRelatedYearDifference;
+}
+
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(HebrewCalendar)
 
 U_NAMESPACE_END

icu4c/source/i18n/hebrwcal.h

@@ -273,21 +273,11 @@ public:
      */
     static UBool isLeapYear(int32_t year) ;
 
-    /**
-     * @return      The related Gregorian year; will be obtained by modifying the value
-     *              obtained by get from UCAL_EXTENDED_YEAR field
-     * @internal
-     */
-    virtual int32_t getRelatedYear(UErrorCode &status) const override;
-
-    /**
-     * @param year  The related Gregorian year to set; will be modified as necessary then
-     *              set in UCAL_EXTENDED_YEAR field
-     * @internal
-     */
-    virtual void setRelatedYear(int32_t year) override;
-
  protected:
+    /**
+     * @internal
+     */
+    int32_t getRelatedYearDifference() const override;
 
     /**
      * Subclass API for defining limits of different types.

icu4c/source/i18n/indiancal.cpp

@@ -296,31 +296,15 @@ void IndianCalendar::handleComputeFields(int32_t julianDay, UErrorCode&  status)
    internalSet(UCAL_DAY_OF_YEAR, yday + 1); // yday is 0-based
 }    
 
-constexpr uint32_t kIndianRelatedYearDiff = 79;
-
-int32_t IndianCalendar::getRelatedYear(UErrorCode &status) const
-{
-    int32_t year = get(UCAL_EXTENDED_YEAR, status);
-    if (U_FAILURE(status)) {
-        return 0;
-    }
-    if (uprv_add32_overflow(year, kIndianRelatedYearDiff, &year)) {
-        status = U_ILLEGAL_ARGUMENT_ERROR;
-        return 0;
-    }
-    return year;
-}
-
-void IndianCalendar::setRelatedYear(int32_t year)
-{
-    // set extended year
-    set(UCAL_EXTENDED_YEAR, year - kIndianRelatedYearDiff);
-}
-
 IMPL_SYSTEM_DEFAULT_CENTURY(IndianCalendar, "@calendar=indian")
 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(IndianCalendar)
 
+int32_t IndianCalendar::getRelatedYearDifference() const {
+    constexpr int32_t kIndianCalendarRelatedYearDifference = 79;
+    return kIndianCalendarRelatedYearDifference;
+}
+
 U_NAMESPACE_END
 
 #endif

icu4c/source/i18n/indiancal.h

@@ -284,27 +284,16 @@ public:
    */
   virtual const char * getType() const override;
 
-  /**
-   * @return      The related Gregorian year; will be obtained by modifying the value
-   *              obtained by get from UCAL_EXTENDED_YEAR field
-   * @internal
-   */
-  virtual int32_t getRelatedYear(UErrorCode &status) const override;
-
-  /**
-   * @param year  The related Gregorian year to set; will be modified as necessary then
-   *              set in UCAL_EXTENDED_YEAR field
-   * @internal
-   */
-  virtual void setRelatedYear(int32_t year) override;
-
-
 private:
   IndianCalendar() = delete; // default constructor not implemented
 
-  // Default century.
 protected:
+  /**
+   * @internal
+   */
+  int32_t getRelatedYearDifference() const override;
 
+  // Default century.
   DECLARE_OVERRIDE_SYSTEM_DEFAULT_CENTURY
 };
 

icu4c/source/i18n/persncal.cpp

@@ -319,30 +319,14 @@ void PersianCalendar::handleComputeFields(int32_t julianDay, UErrorCode& status)
     internalSet(UCAL_DAY_OF_YEAR, dayOfYear);
 }    
 
-constexpr uint32_t kPersianRelatedYearDiff = 622;
-
-int32_t PersianCalendar::getRelatedYear(UErrorCode &status) const
-{
-    int32_t year = get(UCAL_EXTENDED_YEAR, status);
-    if (U_FAILURE(status)) {
-        return 0;
-    }
-    if (uprv_add32_overflow(year, kPersianRelatedYearDiff, &year)) {
-        status = U_ILLEGAL_ARGUMENT_ERROR;
-        return 0;
-    }
-    return year;
-}
-
-void PersianCalendar::setRelatedYear(int32_t year)
-{
-    // set extended year
-    set(UCAL_EXTENDED_YEAR, year - kPersianRelatedYearDiff);
-}
-
 IMPL_SYSTEM_DEFAULT_CENTURY(PersianCalendar, "@calendar=persian")
 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(PersianCalendar)
+int32_t
+PersianCalendar::getRelatedYearDifference() const {
+    constexpr int32_t kPersianCalendarRelatedYearDifference = 622;
+    return kPersianCalendarRelatedYearDifference;
+}
 
 U_NAMESPACE_END
 

icu4c/source/i18n/persncal.h

@@ -278,19 +278,11 @@ class PersianCalendar : public Calendar {
    */
   virtual const char * getType() const override;
 
+ protected:
   /**
-   * @return      The related Gregorian year; will be obtained by modifying the value
-   *              obtained by get from UCAL_EXTENDED_YEAR field
    * @internal
    */
-  virtual int32_t getRelatedYear(UErrorCode &status) const override;
-
-  /**
-   * @param year  The related Gregorian year to set; will be modified as necessary then
-   *              set in UCAL_EXTENDED_YEAR field
-   * @internal
-   */
-  virtual void setRelatedYear(int32_t year) override;
+  int32_t getRelatedYearDifference() const override;
 
  private:
   PersianCalendar(); // default constructor not implemented

icu4c/source/i18n/unicode/calendar.h

@@ -1555,6 +1555,14 @@ protected:
      * @internal
      */
     virtual bool isEra0CountingBackward() const { return false; }
+
+    /**
+     * Related year difference.
+     * @return The difference in Related year.
+     * @internal
+     */
+    virtual int32_t getRelatedYearDifference() const;
+
 #endif  /* U_HIDE_INTERNAL_API */
 
     /**

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

@@ -2302,29 +2302,21 @@ public abstract class Calendar implements Serializable, Cloneable, Comparable<Ca
         set(SECOND, second);
     }
 
-    // -------------------------------------
-    // For now the full getRelatedYear implementation is here;
-    // per #10752 move the non-default implementation to subclasses
-    // (default implementation will do no year adjustment)
-
     /**
-     * utility function for getRelatedYear
+     * @internal
+     * @deprecated This API is ICU internal only.
      */
-    private static int gregoYearFromIslamicStart(int year) {
-        // ad hoc conversion, improve under #10752
-        // rough est for now, ok for grego 1846-2138,
-        // otherwise occasionally wrong (for 3% of years)
-        int cycle, offset, shift = 0;
-        if (year >= 1397) {
-            cycle = (year - 1397) / 67;
-            offset = (year - 1397) % 67;
-            shift = 2*cycle + ((offset >= 33)? 1: 0);
-        } else {
-            cycle = (year - 1396) / 67 - 1;
-            offset = -(year - 1396) % 67;
-            shift = 2*cycle + ((offset <= 33)? 1: 0);
-        }
-        return year + 579 - shift;
+    @Deprecated
+    protected int getRelatedYearDifference() {
+        return 0;
+    }
+    /**
+     * @internal
+     * @deprecated This API is ICU internal only.
+     */
+    @Deprecated
+    public int getRelatedYear() {
+        return get(EXTENDED_YEAR) + getRelatedYearDifference();
     }
 
     /**
@@ -2332,123 +2324,8 @@ public abstract class Calendar implements Serializable, Cloneable, Comparable<Ca
      * @deprecated This API is ICU internal only.
      */
     @Deprecated
-    public final int getRelatedYear() {
-        int year = get(EXTENDED_YEAR);
-        CalType type = CalType.GREGORIAN;
-        String typeString = getType();
-        for (CalType testType : CalType.values()) {
-            if (typeString.equals(testType.getId())) {
-                type = testType;
-                break;
-            }
-        }
-        switch (type) {
-            case PERSIAN:
-                year += 622; break;
-            case HEBREW:
-                year -= 3760; break;
-            case CHINESE:
-                year -= 2637; break;
-            case INDIAN:
-                year += 79; break;
-            case COPTIC:
-                year += 284; break;
-            case ETHIOPIC:
-                year += 8; break;
-            case ETHIOPIC_AMETE_ALEM:
-                year -=5492; break;
-            case DANGI:
-                year -= 2333; break;
-            case ISLAMIC_CIVIL:
-            case ISLAMIC:
-            case ISLAMIC_UMALQURA:
-            case ISLAMIC_TBLA:
-            case ISLAMIC_RGSA:
-                year = gregoYearFromIslamicStart(year); break;
-            // case GREGORIAN:
-            // case JAPANESE:
-            // case BUDDHIST:
-            // case ROC:
-            // case ISO8601:
-            default:
-                // do nothing, EXTENDED_YEAR same as Gregorian
-                break;
-        }
-        return year;
-    }
-
-    // -------------------------------------
-    // For now the full setRelatedYear implementation is here;
-    // per #10752 move the non-default implementation to subclasses
-    // (default implementation will do no year adjustment)
-
-    /**
-     * utility function for setRelatedYear
-     */
-    private static int firstIslamicStartYearFromGrego(int year) {
-        // ad hoc conversion, improve under #10752
-        // rough est for now, ok for grego 1846-2138,
-        // otherwise occasionally wrong (for 3% of years)
-        int cycle, offset, shift = 0;
-        if (year >= 1977) {
-            cycle = (year - 1977) / 65;
-            offset = (year - 1977) % 65;
-            shift = 2*cycle + ((offset >= 32)? 1: 0);
-        } else {
-            cycle = (year - 1976) / 65 - 1;
-            offset = -(year - 1976) % 65;
-            shift = 2*cycle + ((offset <= 32)? 1: 0);
-        }
-        return year - 579 + shift;
-    }
-
-    /**
-     * @internal
-     * @deprecated This API is ICU internal only.
-     */
-    @Deprecated
-    public final void setRelatedYear(int year) {
-        CalType type = CalType.GREGORIAN;
-        String typeString = getType();
-        for (CalType testType : CalType.values()) {
-            if (typeString.equals(testType.getId())) {
-                type = testType;
-                break;
-            }
-        }
-        switch (type) {
-            case PERSIAN:
-                year -= 622; break;
-            case HEBREW:
-                year += 3760; break;
-            case CHINESE:
-                year += 2637; break;
-            case INDIAN:
-                year -= 79; break;
-            case COPTIC:
-                year -= 284; break;
-            case ETHIOPIC:
-                year -= 8; break;
-            case ETHIOPIC_AMETE_ALEM:
-                year +=5492; break;
-            case DANGI:
-                year += 2333; break;
-            case ISLAMIC_CIVIL:
-            case ISLAMIC:
-            case ISLAMIC_UMALQURA:
-            case ISLAMIC_TBLA:
-            case ISLAMIC_RGSA:
-                year = firstIslamicStartYearFromGrego(year); break;
-            // case GREGORIAN:
-            // case JAPANESE:
-            // case BUDDHIST:
-            // case ROC:
-            // case ISO8601:
-            default:
-                // do nothing, EXTENDED_YEAR same as Gregorian
-                break;
-        }
-        set(EXTENDED_YEAR, year);
+    public void setRelatedYear(int year) {
+        set(EXTENDED_YEAR, year - getRelatedYearDifference());
     }
 
     /**

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

@@ -1186,6 +1186,15 @@ public class ChineseCalendar extends Calendar {
 
     }
 
+    /**
+     * @internal
+     * @deprecated This API is ICU internal only.
+     */
+    @Deprecated
+    protected final int getRelatedYearDifference() {
+        return epochYear - 1;
+    }
+
     /*
     private static CalendarFactory factory;
     public static CalendarFactory factory() {

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

@@ -335,5 +335,16 @@ public final class CopticCalendar extends CECalendar
     public static int copticToJD(long year, int month, int date) {
         return ceToJD(year, month, date, JD_EPOCH_OFFSET);
     }
+
+    private static final int COPTIC_CALENDAR_RELATED_YEAR_DIFFERENCE = 284;
+
+    /**
+     * @internal
+     * @deprecated This API is ICU internal only.
+     */
+    @Deprecated
+    protected final int getRelatedYearDifference() {
+        return COPTIC_CALENDAR_RELATED_YEAR_DIFFERENCE;
+    }
 }
 

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

@@ -400,6 +400,22 @@ public final class EthiopicCalendar extends CECalendar
         return ceToJD(year, month, date, JD_EPOCH_OFFSET_AMETE_MIHRET);
     }
 
+
+    private static final int ETHIOPIC_AMETE_ALEM_CALENDAR_RELATED_YEAR_DIFFERENCE = -5492;
+
+    private static final int ETHIOPIC_CALENDAR_RELATED_YEAR_DIFFERENCE = 8;
+
+    /**
+     * @internal
+     * @deprecated This API is ICU internal only.
+     */
+    @Deprecated
+    protected final int getRelatedYearDifference() {
+        return isAmeteAlemEra() ?
+            ETHIOPIC_AMETE_ALEM_CALENDAR_RELATED_YEAR_DIFFERENCE :
+            ETHIOPIC_CALENDAR_RELATED_YEAR_DIFFERENCE;
+    }
+
     /**
      * set type based on locale
      */

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

@@ -914,6 +914,17 @@ public class HebrewCalendar extends Calendar {
         return "hebrew";
     }
 
+    private static final int HEBREW_CALENDAR_RELATED_YEAR_DIFFERENCE = -3760;
+
+    /**
+     * @internal
+     * @deprecated This API is ICU internal only.
+     */
+    @Deprecated
+    protected final int getRelatedYearDifference() {
+        return HEBREW_CALENDAR_RELATED_YEAR_DIFFERENCE;
+    }
+
     //-------------------------------------------------------------------------
     // Temporal Calendar API.
     //-------------------------------------------------------------------------

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

@@ -499,7 +499,18 @@ public class IndianCalendar extends Calendar {
 
        return jd;
     }
-    
+
+    private static final int INDIAN_CALENDAR_RELATED_YEAR_DIFFERENCE = 79;
+
+    /**
+     * @internal
+     * @deprecated This API is ICU internal only.
+     */
+    @Deprecated
+    protected final int getRelatedYearDifference() {
+        return INDIAN_CALENDAR_RELATED_YEAR_DIFFERENCE;
+    }
+
     /*
      * The following function is not needed for basic calendar functioning.
      * This routine converts a gregorian date to the corresponding Julian date"

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

@@ -1130,6 +1130,63 @@ public class IslamicCalendar extends Calendar {
         civil = algorithm.isCivil();
     }
 
+    /**
+     * utility function for getRelatedYear
+     */
+    private static final int gregoYearFromIslamicStart(int year) {
+        // ad hoc conversion, improve under #10752
+        // rough est for now, ok for grego 1846-2138,
+        // otherwise occasionally wrong (for 3% of years)
+        int cycle, offset, shift = 0;
+        if (year >= 1397) {
+            cycle = (year - 1397) / 67;
+            offset = (year - 1397) % 67;
+            shift = 2*cycle + ((offset >= 33)? 1: 0);
+        } else {
+            cycle = (year - 1396) / 67 - 1;
+            offset = -(year - 1396) % 67;
+            shift = 2*cycle + ((offset <= 33)? 1: 0);
+        }
+        return year + 579 - shift;
+    }
+
+    /**
+     * @internal
+     * @deprecated This API is ICU internal only.
+     */
+     @Deprecated
+    public final int getRelatedYear() {
+        return gregoYearFromIslamicStart(get(EXTENDED_YEAR));
+    }
+
+    /**
+     * utility function for setRelatedYear
+     */
+    private static int firstIslamicStartYearFromGrego(int year) {
+        // ad hoc conversion, improve under #10752
+        // rough est for now, ok for grego 1846-2138,
+        // otherwise occasionally wrong (for 3% of years)
+        int cycle, offset, shift = 0;
+        if (year >= 1977) {
+            cycle = (year - 1977) / 65;
+            offset = (year - 1977) % 65;
+            shift = 2*cycle + ((offset >= 32)? 1: 0);
+        } else {
+            cycle = (year - 1976) / 65 - 1;
+            offset = -(year - 1976) % 65;
+            shift = 2*cycle + ((offset <= 32)? 1: 0);
+        }
+        return year - 579 + shift;
+    }
+
+    /*
+     * @deprecated This API is ICU internal only.
+     */
+    @Deprecated
+    public final void setRelatedYear(int year) {
+        set(EXTENDED_YEAR, firstIslamicStartYearFromGrego(year));
+    }
+
     /**
      * gets the calculation type for this calendar.
      *

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

@@ -489,6 +489,16 @@ public class PersianCalendar extends Calendar {
         internalSet(DAY_OF_YEAR, dayOfYear);       
     }    
 
+    private static final int PERSIAN_CALENDAR_RELATED_YEAR_DIFFERENCE = 622;
+    /**
+     * @internal
+     * @deprecated This API is ICU internal only.
+     */
+    @Deprecated
+    protected final int getRelatedYearDifference() {
+        return PERSIAN_CALENDAR_RELATED_YEAR_DIFFERENCE;
+    }
+
     /**
      * {@inheritDoc}
      *