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