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