The Tor Browser / file comparison
comparison: intl/icu/source/i18n/chnsecal.h
intl/icu/source/i18n/chnsecal.h
- branch
- TOR_BUG_9701
- changeset 15
- b8a032363ba2
equal
deleted
inserted
replaced
| -1:000000000000 | 0:d0fe6776ccc4 |
|---|---|
| 1 /* | |
| 2 ***************************************************************************** | |
| 3 * Copyright (C) 2007-2013, International Business Machines Corporation | |
| 4 * and others. All Rights Reserved. | |
| 5 ***************************************************************************** | |
| 6 * | |
| 7 * File CHNSECAL.H | |
| 8 * | |
| 9 * Modification History: | |
| 10 * | |
| 11 * Date Name Description | |
| 12 * 9/18/2007 ajmacher ported from java ChineseCalendar | |
| 13 ***************************************************************************** | |
| 14 */ | |
| 15 | |
| 16 #ifndef CHNSECAL_H | |
| 17 #define CHNSECAL_H | |
| 18 | |
| 19 #include "unicode/utypes.h" | |
| 20 | |
| 21 #if !UCONFIG_NO_FORMATTING | |
| 22 | |
| 23 #include "unicode/calendar.h" | |
| 24 #include "unicode/timezone.h" | |
| 25 | |
| 26 U_NAMESPACE_BEGIN | |
| 27 | |
| 28 /** | |
| 29 * <code>ChineseCalendar</code> is a concrete subclass of {@link Calendar} | |
| 30 * that implements a traditional Chinese calendar. The traditional Chinese | |
| 31 * calendar is a lunisolar calendar: Each month starts on a new moon, and | |
| 32 * the months are numbered according to solar events, specifically, to | |
| 33 * guarantee that month 11 always contains the winter solstice. In order | |
| 34 * to accomplish this, leap months are inserted in certain years. Leap | |
| 35 * months are numbered the same as the month they follow. The decision of | |
| 36 * which month is a leap month depends on the relative movements of the sun | |
| 37 * and moon. | |
| 38 * | |
| 39 * <p>This class defines one addition field beyond those defined by | |
| 40 * <code>Calendar</code>: The <code>IS_LEAP_MONTH</code> field takes the | |
| 41 * value of 0 for normal months, or 1 for leap months. | |
| 42 * | |
| 43 * <p>All astronomical computations are performed with respect to a time | |
| 44 * zone of GMT+8:00 and a longitude of 120 degrees east. Although some | |
| 45 * calendars implement a historically more accurate convention of using | |
| 46 * Beijing's local longitude (116 degrees 25 minutes east) and time zone | |
| 47 * (GMT+7:45:40) for dates before 1929, we do not implement this here. | |
| 48 * | |
| 49 * <p>Years are counted in two different ways in the Chinese calendar. The | |
| 50 * first method is by sequential numbering from the 61st year of the reign | |
| 51 * of Huang Di, 2637 BCE, which is designated year 1 on the Chinese | |
| 52 * calendar. The second method uses 60-year cycles from the same starting | |
| 53 * point, which is designated year 1 of cycle 1. In this class, the | |
| 54 * <code>EXTENDED_YEAR</code> field contains the sequential year count. | |
| 55 * The <code>ERA</code> field contains the cycle number, and the | |
| 56 * <code>YEAR</code> field contains the year of the cycle, a value between | |
| 57 * 1 and 60. | |
| 58 * | |
| 59 * <p>There is some variation in what is considered the starting point of | |
| 60 * the calendar, with some sources starting in the first year of the reign | |
| 61 * of Huang Di, rather than the 61st. This gives continuous year numbers | |
| 62 * 60 years greater and cycle numbers one greater than what this class | |
| 63 * implements. | |
| 64 * | |
| 65 * <p>Because <code>ChineseCalendar</code> defines an additional field and | |
| 66 * redefines the way the <code>ERA</code> field is used, it requires a new | |
| 67 * format class, <code>ChineseDateFormat</code>. As always, use the | |
| 68 * methods <code>DateFormat.getXxxInstance(Calendar cal,...)</code> to | |
| 69 * obtain a formatter for this calendar. | |
| 70 * | |
| 71 * <p>References:<ul> | |
| 72 * | |
| 73 * <li>Dershowitz and Reingold, <i>Calendrical Calculations</i>, | |
| 74 * Cambridge University Press, 1997</li> | |
| 75 * | |
| 76 * <li>Helmer Aslaksen's | |
| 77 * <a href="http://www.math.nus.edu.sg/aslaksen/calendar/chinese.shtml"> | |
| 78 * Chinese Calendar page</a></li> | |
| 79 * | |
| 80 * <li>The <a href="http://www.tondering.dk/claus/calendar.html"> | |
| 81 * Calendar FAQ</a></li> | |
| 82 * | |
| 83 * </ul> | |
| 84 * | |
| 85 * <p> | |
| 86 * This class should only be subclassed to implement variants of the Chinese lunar calendar.</p> | |
| 87 * <p> | |
| 88 * ChineseCalendar usually should be instantiated using | |
| 89 * {@link com.ibm.icu.util.Calendar#getInstance(ULocale)} passing in a <code>ULocale</code> | |
| 90 * with the tag <code>"@calendar=chinese"</code>.</p> | |
| 91 * | |
| 92 * @see com.ibm.icu.text.ChineseDateFormat | |
| 93 * @see com.ibm.icu.util.Calendar | |
| 94 * @author Alan Liu | |
| 95 * @internal | |
| 96 */ | |
| 97 class U_I18N_API ChineseCalendar : public Calendar { | |
| 98 public: | |
| 99 //------------------------------------------------------------------------- | |
| 100 // Constructors... | |
| 101 //------------------------------------------------------------------------- | |
| 102 | |
| 103 /** | |
| 104 * Constructs a ChineseCalendar based on the current time in the default time zone | |
| 105 * with the given locale. | |
| 106 * | |
| 107 * @param aLocale The given locale. | |
| 108 * @param success Indicates the status of ChineseCalendar object construction. | |
| 109 * Returns U_ZERO_ERROR if constructed successfully. | |
| 110 * @internal | |
| 111 */ | |
| 112 ChineseCalendar(const Locale& aLocale, UErrorCode &success); | |
| 113 | |
| 114 protected: | |
| 115 | |
| 116 /** | |
| 117 * Constructs a ChineseCalendar based on the current time in the default time zone | |
| 118 * with the given locale, using the specified epoch year and time zone for | |
| 119 * astronomical calculations. | |
| 120 * | |
| 121 * @param aLocale The given locale. | |
| 122 * @param epochYear The epoch year to use for calculation. | |
| 123 * @param zoneAstroCalc The TimeZone to use for astronomical calculations. If null, | |
| 124 * will be set appropriately for Chinese calendar (UTC + 8:00). | |
| 125 * @param success Indicates the status of ChineseCalendar object construction; | |
| 126 * if successful, will not be changed to an error value. | |
| 127 * @internal | |
| 128 */ | |
| 129 ChineseCalendar(const Locale& aLocale, int32_t epochYear, const TimeZone* zoneAstroCalc, UErrorCode &success); | |
| 130 | |
| 131 public: | |
| 132 /** | |
| 133 * Copy Constructor | |
| 134 * @internal | |
| 135 */ | |
| 136 ChineseCalendar(const ChineseCalendar& other); | |
| 137 | |
| 138 /** | |
| 139 * Destructor. | |
| 140 * @internal | |
| 141 */ | |
| 142 virtual ~ChineseCalendar(); | |
| 143 | |
| 144 // clone | |
| 145 virtual Calendar* clone() const; | |
| 146 | |
| 147 private: | |
| 148 | |
| 149 //------------------------------------------------------------------------- | |
| 150 // Internal data.... | |
| 151 //------------------------------------------------------------------------- | |
| 152 | |
| 153 UBool isLeapYear; | |
| 154 int32_t fEpochYear; // Start year of this Chinese calendar instance. | |
| 155 const TimeZone* fZoneAstroCalc; // Zone used for the astronomical calculation | |
| 156 // of this Chinese calendar instance. | |
| 157 | |
| 158 //---------------------------------------------------------------------- | |
| 159 // Calendar framework | |
| 160 //---------------------------------------------------------------------- | |
| 161 | |
| 162 protected: | |
| 163 virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const; | |
| 164 virtual int32_t handleGetMonthLength(int32_t extendedYear, int32_t month) const; | |
| 165 virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const; | |
| 166 virtual int32_t handleGetExtendedYear(); | |
| 167 virtual void handleComputeFields(int32_t julianDay, UErrorCode &status); | |
| 168 virtual const UFieldResolutionTable* getFieldResolutionTable() const; | |
| 169 | |
| 170 public: | |
| 171 virtual void add(UCalendarDateFields field, int32_t amount, UErrorCode &status); | |
| 172 virtual void add(EDateFields field, int32_t amount, UErrorCode &status); | |
| 173 virtual void roll(UCalendarDateFields field, int32_t amount, UErrorCode &status); | |
| 174 virtual void roll(EDateFields field, int32_t amount, UErrorCode &status); | |
| 175 | |
| 176 //---------------------------------------------------------------------- | |
| 177 // Internal methods & astronomical calculations | |
| 178 //---------------------------------------------------------------------- | |
| 179 | |
| 180 private: | |
| 181 | |
| 182 static const UFieldResolutionTable CHINESE_DATE_PRECEDENCE[]; | |
| 183 | |
| 184 double daysToMillis(double days) const; | |
| 185 double millisToDays(double millis) const; | |
| 186 virtual int32_t winterSolstice(int32_t gyear) const; | |
| 187 virtual int32_t newMoonNear(double days, UBool after) const; | |
| 188 virtual int32_t synodicMonthsBetween(int32_t day1, int32_t day2) const; | |
| 189 virtual int32_t majorSolarTerm(int32_t days) const; | |
| 190 virtual UBool hasNoMajorSolarTerm(int32_t newMoon) const; | |
| 191 virtual UBool isLeapMonthBetween(int32_t newMoon1, int32_t newMoon2) const; | |
| 192 virtual void computeChineseFields(int32_t days, int32_t gyear, | |
| 193 int32_t gmonth, UBool setAllFields); | |
| 194 virtual int32_t newYear(int32_t gyear) const; | |
| 195 virtual void offsetMonth(int32_t newMoon, int32_t dom, int32_t delta); | |
| 196 const TimeZone* getChineseCalZoneAstroCalc(void) const; | |
| 197 | |
| 198 // UObject stuff | |
| 199 public: | |
| 200 /** | |
| 201 * @return The class ID for this object. All objects of a given class have the | |
| 202 * same class ID. Objects of other classes have different class IDs. | |
| 203 * @internal | |
| 204 */ | |
| 205 virtual UClassID getDynamicClassID(void) const; | |
| 206 | |
| 207 /** | |
| 208 * Return the class ID for this class. This is useful only for comparing to a return | |
| 209 * value from getDynamicClassID(). For example: | |
| 210 * | |
| 211 * Base* polymorphic_pointer = createPolymorphicObject(); | |
| 212 * if (polymorphic_pointer->getDynamicClassID() == | |
| 213 * Derived::getStaticClassID()) ... | |
| 214 * | |
| 215 * @return The class ID for all objects of this class. | |
| 216 * @internal | |
| 217 */ | |
| 218 static UClassID U_EXPORT2 getStaticClassID(void); | |
| 219 | |
| 220 /** | |
| 221 * return the calendar type, "chinese". | |
| 222 * | |
| 223 * @return calendar type | |
| 224 * @internal | |
| 225 */ | |
| 226 virtual const char * getType() const; | |
| 227 | |
| 228 | |
| 229 protected: | |
| 230 /** | |
| 231 * (Overrides Calendar) Return true if the current date for this Calendar is in | |
| 232 * Daylight Savings Time. Recognizes DST_OFFSET, if it is set. | |
| 233 * | |
| 234 * @param status Fill-in parameter which receives the status of this operation. | |
| 235 * @return True if the current date for this Calendar is in Daylight Savings Time, | |
| 236 * false, otherwise. | |
| 237 * @internal | |
| 238 */ | |
| 239 virtual UBool inDaylightTime(UErrorCode& status) const; | |
| 240 | |
| 241 | |
| 242 /** | |
| 243 * Returns TRUE because the Islamic Calendar does have a default century | |
| 244 * @internal | |
| 245 */ | |
| 246 virtual UBool haveDefaultCentury() const; | |
| 247 | |
| 248 /** | |
| 249 * Returns the date of the start of the default century | |
| 250 * @return start of century - in milliseconds since epoch, 1970 | |
| 251 * @internal | |
| 252 */ | |
| 253 virtual UDate defaultCenturyStart() const; | |
| 254 | |
| 255 /** | |
| 256 * Returns the year in which the default century begins | |
| 257 * @internal | |
| 258 */ | |
| 259 virtual int32_t defaultCenturyStartYear() const; | |
| 260 | |
| 261 private: // default century stuff. | |
| 262 | |
| 263 /** | |
| 264 * Returns the beginning date of the 100-year window that dates | |
| 265 * with 2-digit years are considered to fall within. | |
| 266 */ | |
| 267 UDate internalGetDefaultCenturyStart(void) const; | |
| 268 | |
| 269 /** | |
| 270 * Returns the first year of the 100-year window that dates with | |
| 271 * 2-digit years are considered to fall within. | |
| 272 */ | |
| 273 int32_t internalGetDefaultCenturyStartYear(void) const; | |
| 274 | |
| 275 ChineseCalendar(); // default constructor not implemented | |
| 276 }; | |
| 277 | |
| 278 U_NAMESPACE_END | |
| 279 | |
| 280 #endif | |
| 281 #endif |
