1 // © 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /* 4 ******************************************************************************** 5 * Copyright (C) 2003-2008, International Business Machines Corporation 6 * and others. All Rights Reserved. 7 ******************************************************************************** 8 * 9 * File JAPANCAL.H 10 * 11 * Modification History: 12 * 13 * Date Name Description 14 * 05/13/2003 srl copied from gregocal.h 15 ******************************************************************************** 16 */ 17 18 #ifndef JAPANCAL_H 19 #define JAPANCAL_H 20 21 #include "unicode/utypes.h" 22 23 #if !UCONFIG_NO_FORMATTING 24 25 #include "unicode/calendar.h" 26 #include "unicode/gregocal.h" 27 28 U_NAMESPACE_BEGIN 29 30 /** 31 * Concrete class which provides the Japanese calendar. 32 * <P> 33 * <code>JapaneseCalendar</code> is a subclass of <code>GregorianCalendar</code> 34 * that numbers years and eras based on the reigns of the Japanese emperors. 35 * The Japanese calendar is identical to the Gregorian calendar in all respects 36 * except for the year and era. The ascension of each emperor to the throne 37 * begins a new era, and the years of that era are numbered starting with the 38 * year of ascension as year 1. 39 * <p> 40 * Note that in the year of an imperial ascension, there are two possible sets 41 * of year and era values: that for the old era and for the new. For example, a 42 * new era began on January 7, 1989 AD. Strictly speaking, the first six days 43 * of that year were in the Showa era, e.g. "January 6, 64 Showa", while the rest 44 * of the year was in the Heisei era, e.g. "January 7, 1 Heisei". This class 45 * handles this distinction correctly when computing dates. However, in lenient 46 * mode either form of date is acceptable as input. 47 * <p> 48 * In modern times, eras have started on January 8, 1868 AD, Gregorian (Meiji), 49 * July 30, 1912 (Taisho), December 25, 1926 (Showa), and January 7, 1989 (Heisei). Constants 50 * for these eras, suitable for use in the <code>UCAL_ERA</code> field, are provided 51 * in this class. Note that the <em>number</em> used for each era is more or 52 * less arbitrary. Currently, the era starting in 645 AD is era #0; however this 53 * may change in the future. Use the predefined constants rather than using actual, 54 * absolute numbers. 55 * <p> 56 * Since ICU4C 63, start date of each era is imported from CLDR. CLDR era data 57 * may contain tentative era in near future with placeholder names. By default, 58 * such era data is not enabled. ICU4C users who want to test the behavior of 59 * the future era can enable this one of following settings (in the priority 60 * order): 61 * <ol> 62 * <li>Environment variable <code>ICU_ENABLE_TENTATIVE_ERA=true</code>.</li> 63 * </nl> 64 * @internal 65 */ 66 class JapaneseCalendar : public GregorianCalendar { 67 public: 68 69 /** 70 * Check environment variable. 71 * @internal 72 */ 73 U_I18N_API static UBool U_EXPORT2 enableTentativeEra(); 74 75 /** 76 * Useful constants for JapaneseCalendar. 77 * Exported for use by test code. 78 * @internal 79 */ 80 U_I18N_API static uint32_t U_EXPORT2 getCurrentEra(); // the current era 81 82 /** 83 * Constructs a JapaneseCalendar based on the current time in the default time zone 84 * with the given locale. 85 * 86 * @param aLocale The given locale. 87 * @param success Indicates the status of JapaneseCalendar object construction. 88 * Returns U_ZERO_ERROR if constructed successfully. 89 * @stable ICU 2.0 90 */ 91 JapaneseCalendar(const Locale& aLocale, UErrorCode& success); 92 93 94 /** 95 * Destructor 96 * @internal 97 */ 98 virtual ~JapaneseCalendar(); 99 100 /** 101 * Copy constructor 102 * @param source the object to be copied. 103 * @internal 104 */ 105 JapaneseCalendar(const JapaneseCalendar& source); 106 107 /** 108 * Default assignment operator 109 * @param right the object to be copied. 110 * @internal 111 */ 112 JapaneseCalendar& operator=(const JapaneseCalendar& right); 113 114 /** 115 * Create and return a polymorphic copy of this calendar. 116 * @return return a polymorphic copy of this calendar. 117 * @internal 118 */ 119 virtual JapaneseCalendar* clone() const override; 120 121 /** 122 * Return the extended year defined by the current fields. In the 123 * Japanese calendar case, this is equal to the equivalent extended Gregorian year. 124 * @internal 125 */ 126 virtual int32_t handleGetExtendedYear(UErrorCode& status) override; 127 128 /** 129 * Return the maximum value that this field could have, given the current date. 130 * @internal 131 */ 132 virtual int32_t getActualMaximum(UCalendarDateFields field, UErrorCode& status) const override; 133 134 135 public: 136 /** 137 * Override Calendar Returns a unique class ID POLYMORPHICALLY. Pure virtual 138 * override. This method is to implement a simple version of RTTI, since not all C++ 139 * compilers support genuine RTTI. Polymorphic operator==() and clone() methods call 140 * this method. 141 * 142 * @return The class ID for this object. All objects of a given class have the 143 * same class ID. Objects of other classes have different class IDs. 144 * @internal 145 */ 146 virtual UClassID getDynamicClassID() const override; 147 148 /** 149 * Return the class ID for this class. This is useful only for comparing to a return 150 * value from getDynamicClassID(). For example: 151 * 152 * Base* polymorphic_pointer = createPolymorphicObject(); 153 * if (polymorphic_pointer->getDynamicClassID() == 154 * Derived::getStaticClassID()) ... 155 * 156 * @return The class ID for all objects of this class. 157 * @internal 158 */ 159 U_I18N_API static UClassID U_EXPORT2 getStaticClassID(); 160 161 /** 162 * return the calendar type, "japanese". 163 * 164 * @return calendar type 165 * @internal 166 */ 167 virtual const char * getType() const override; 168 169 DECLARE_OVERRIDE_SYSTEM_DEFAULT_CENTURY 170 171 private: 172 JapaneseCalendar(); // default constructor not implemented 173 174 protected: 175 /** 176 * Calculate the era for internal computation 177 * @internal 178 */ 179 virtual int32_t internalGetEra() const override; 180 181 /** 182 * Compute fields from the JD 183 * @internal 184 */ 185 virtual void handleComputeFields(int32_t julianDay, UErrorCode& status) override; 186 187 /** 188 * Calculate the limit for a specified type of limit and field 189 * @internal 190 */ 191 virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const override; 192 193 /*** 194 * Called by computeJulianDay. Returns the default month (0-based) for the year, 195 * taking year and era into account. Will return the first month of the given era, if 196 * the current year is an ascension year. 197 * @param eyear the extended year 198 * @internal 199 */ 200 virtual int32_t getDefaultMonthInYear(int32_t eyear, UErrorCode& status) override; 201 202 /*** 203 * Called by computeJulianDay. Returns the default day (1-based) for the month, 204 * taking currently-set year and era into account. Will return the first day of the given 205 * era, if the current month is an ascension year and month. 206 * @param eyear the extended year 207 * @param mon the month in the year 208 * @internal 209 */ 210 virtual int32_t getDefaultDayInMonth(int32_t eyear, int32_t month) override; 211 isEra0CountingBackward()212 virtual bool isEra0CountingBackward() const override { return false; } 213 }; 214 215 U_NAMESPACE_END 216 217 #endif /* #if !UCONFIG_NO_FORMATTING */ 218 219 #endif 220 //eof 221 222